public async Task <int> GetUserProfilesCount(Guid[] appUserIds, CommonSpecParams specParams)
{
var specs = new GetUserProfilesByUserIdsCountSpecification(appUserIds, specParams);
var count = await _unitOfWork.Repository <UserProfile>().CountAsync(specs);
return(count);
}
public async Task <IActionResult> GetSdrsUnderManager(int managerId, [FromQuery] CommonSpecParams specParams)
{
try
{
var validationResponse = await _sdrGroupingService.ValidateManagerIdGetInput(managerId);
if (!validationResponse.IsSuccess)
{
return(BadRequest(new ApiResponse(validationResponse.StatusCode, validationResponse.Message)));
}
var sdrGroupingDetails = await _sdrGroupingService.GetSdrGroupingByManageId(managerId, specParams);
var managerMapped = _mapper.Map <GetUserProfileOutputDto>(sdrGroupingDetails.Item1);
var sdrListMapped = _mapper.Map <IReadOnlyList <GetUserProfileOutputDto> >(sdrGroupingDetails.Item2);
var count = sdrGroupingDetails.Item3;
return(Ok(new {
Manager = managerMapped,
Sdrs = new Pagination <GetUserProfileOutputDto>(specParams.PageIndex, specParams.PageSize, count, sdrListMapped)
}));
}
catch
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
public async Task <int> GetUserProfilesCountByDepartment(int departmentId, CommonSpecParams specParams)
{
var specs = new GetUserProfilesByDepartmentCountSpecification(departmentId, specParams);
var count = await _unitOfWork.Repository <UserProfile>().CountAsync(specs);
return(count);
}
public async Task <IReadOnlyList <Department> > GetDepartments(CommonSpecParams specParams)
{
var specs = new GetDepartmentsSpecification(specParams);
var departments = await _unitOfWork.Repository <Department>().ListAsync(specs);
return(departments);
}
public async Task <int> GetDepartmentsCount(CommonSpecParams specParams)
{
var specs = new GetDepartmentsCountSpecification(specParams);
var count = await _unitOfWork.Repository <Department>().CountAsync(specs);
return(count);
}
public async Task <IReadOnlyList <UserProfile> > GetUserProfiles(CommonSpecParams specParams)
{
var spec = new GetUserProfilesSpecification(specParams);
var userProfiles = await _unitOfWork.Repository <UserProfile>().ListAsync(spec);
return(userProfiles);
}
public async Task <IActionResult> GetAdminUserProfiles([FromQuery] CommonSpecParams specParams)
{
try
{
var users = await _userAccountService.GetUserAccountsByRole("admin");
if (users != null)
{
var userIds = users.Select(s => s.Id).ToArray();
var userProfiles = await _userProfileService.GetUserProfiles(userIds, specParams);
var userProfilesMapped = _mapper.Map <IReadOnlyList <GetUserProfileOutputDto> >(userProfiles);
userProfilesMapped = userProfilesMapped.Select(s =>
{
s.RoleId = _userProfileService.GetRoleByUserProfileId(s.id).Result;
return(s);
}).ToList();
var count = await _userProfileService.GetUserProfilesCount(userIds, specParams);
return(Ok(new Pagination <GetUserProfileOutputDto>(specParams.PageIndex, specParams.PageSize, count, userProfilesMapped)));
}
else
{
return(Ok(new ApiResponse(200, "No records found.")));
}
}
catch
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
public async Task <IActionResult> GetAllUserAccounts([FromQuery] CommonSpecParams specParams)
{
var userAccounts = await _userAccountService.GetUserAccounts(specParams);
var count = userAccounts.Item1;
return(Ok(new Pagination <UserAccountOutputDto>(specParams.PageIndex, specParams.PageSize, count, userAccounts.Item2.ToList())));
}
public async Task <IActionResult> GetCampaigns([FromQuery] CommonSpecParams specParams)
{
try
{
var campaigns = await _campaignService.GetCampaigns(specParams);
var campaignsMapped = _mapper.Map <IReadOnlyList <GetCampaignOutputDto> >(campaigns);
var count = await _campaignService.GetCampaignsCount(specParams);
return(Ok(new Pagination <GetCampaignOutputDto>(specParams.PageIndex, specParams.PageSize, count, campaignsMapped)));
}
catch
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
public async Task <IActionResult> GetUserProfiles([FromQuery] CommonSpecParams specParams)
{
try
{
var userProfiles = await _userProfileService.GetUserProfiles(specParams);
var userProfilesMapped = _mapper.Map <IReadOnlyList <GetUserProfileOutputDto> >(userProfiles);
userProfilesMapped = userProfilesMapped.Select(s =>
{
s.RoleId = _userProfileService.GetRoleByUserProfileId(s.id).Result;
return(s);
}).ToList();
var count = await _userProfileService.GetUserProfilesCount(specParams);
return(Ok(new Pagination <GetUserProfileOutputDto>(specParams.PageIndex, specParams.PageSize, count, userProfilesMapped)));
}
catch
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
public async Task <IActionResult> GetSchedulerBySdr([FromQuery] CommonSpecParams specParams)
{
try
{
var user = await _userManager.FindByEmailFromClaimsPrinciple(HttpContext.User);
var schedulerResponse = await _schedulerService.GetSchedulers(user.Id, specParams);
var schedulersMapped = _mapper.Map <IReadOnlyList <SchedulerOutputDto> >(schedulerResponse.Item2);
var campaignMapped = _mapper.Map <GetCampaignForSchedulerOutputDto>(schedulerResponse.Item3);
var contentMapped = _mapper.Map <ContentOutputDto>(schedulerResponse.Item4);
campaignMapped.Content = contentMapped;
var count = schedulerResponse.Item1;
return(Ok(new {
Schedulers = new Pagination <SchedulerOutputDto>(specParams.PageIndex, specParams.PageSize, count, schedulersMapped),
Campaign = campaignMapped
}));
}
catch
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
public async Task <(UserProfile, IReadOnlyList <SdrGrouping>, int)> GetSdrGroupingByManageId(int managerId, CommonSpecParams specParams)
{
var manager = await _unitOfWork.Repository <UserProfile>().GetByIdAsync(managerId);
var sdrsSpecs = new GetSdrGroupByManagerIdSpecification(managerId, specParams);
var sdrList = await _unitOfWork.Repository <SdrGrouping>().ListAsync(sdrsSpecs);
var sdrsCountSpecs = new GetSdrGroupByManagerIdSpecification(managerId, specParams);
var count = await _unitOfWork.Repository <SdrGrouping>().CountAsync(sdrsSpecs);
return(manager, sdrList, count);
}
public async Task <IActionResult> GetUserProfilesByDepartment(int departmentId, [FromQuery] CommonSpecParams specParams)
{
try
{
var userProfiles = await _userProfileService.GetUserProfilesByDepartment(departmentId, specParams);
var userProfilesMapped = _mapper.Map <IReadOnlyList <GetUserProfileOutputDto> >(userProfiles);
var count = await _userProfileService.GetUserProfilesCountByDepartment(departmentId, specParams);
return(Ok(new Pagination <GetUserProfileOutputDto>(specParams.PageIndex, specParams.PageSize, count, userProfilesMapped)));
}
catch
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
public async Task <ActionResult <Pagination <GetDepartmentOutputDto> > > GetAllDepartments([FromQuery] CommonSpecParams specParams)
{
try
{
var departments = await _departmentService.GetDepartments(specParams);
var departmentsMapped = _mapper.Map <IReadOnlyList <GetDepartmentOutputDto> >(departments);
var count = await _departmentService.GetDepartmentsCount(specParams);
return(Ok(new Pagination <GetDepartmentOutputDto>(specParams.PageIndex, specParams.PageSize, count, departmentsMapped)));
}
catch
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
public async Task <(int, IReadOnlyList <Scheduler>, Campaign, Content)> GetSchedulers(Guid userId, CommonSpecParams specParams)
{
var userProfile = await _userProfileService.GetUserProfileByUserId(userId);
var campaignAssignment = await _campaignAssignmentService.GetActiveCampaignAssignment(userProfile.id);
if (campaignAssignment == null)
{
return(0, null, null, null);
}
var specGetScheduler = new GetSchedulerSpecification(specParams, campaignAssignment.CampaignId, campaignAssignment.UserProfileId);
var schedulers = await _unitOfWork.Repository <Scheduler>().ListAsync(specGetScheduler);
var campaign = campaignAssignment.Campaign;
var content = await _contentService.GetContentByCampaignId(campaign.id);
var specSchedulerCount = new GetSchedulerCountSpecification(specParams, campaignAssignment.CampaignId, campaignAssignment.UserProfileId);
var count = await _unitOfWork.Repository <Scheduler>().CountAsync(specSchedulerCount);
return(count, schedulers, campaign, content);
}
public async Task <IReadOnlyList <Wage> > GetWagesAsync(CommonSpecParams specParams)
{
var specs = new GetWagesSpecification(specParams);
return(await _unitOfWork.Repository <Wage>().ListAsync(specs));
}
public async Task <IActionResult> GetScheduler(int campaignId, int userProfileId, [FromQuery] CommonSpecParams specParams)
{
try
{
var validationResponse = await _schedulerService.ValidateGetInput(campaignId, userProfileId);
if (!validationResponse.IsSuccess)
{
return(BadRequest(new ApiResponse(validationResponse.StatusCode, validationResponse.Message)));
}
var schedulerResponse = await _schedulerService.GetSchedulers(campaignId, userProfileId, specParams);
var schedulersMapped = _mapper.Map <IReadOnlyList <SchedulerOutputDto> >(schedulerResponse.Item2);
var count = schedulerResponse.Item1;
return(Ok(new Pagination <SchedulerOutputDto>(specParams.PageIndex, specParams.PageSize, count, schedulersMapped)));
}
catch
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
public async Task <(IReadOnlyList <UserProfile>, int)> GetSdrsFromCampaign(int campaignId, CommonSpecParams specParams)
{
var specs = new GetCampaignSdrsSpecification(campaignId);
var campaignAssignments = await _unitOfWork.Repository <CampaignAssignment>().ListAsync(specs);
var skip = specParams.PageSize * (specParams.PageIndex - 1);
var take = specParams.PageSize;
var sdrs = campaignAssignments.Select(s => {
s.UserProfile.StatusId = s.StatusId;
return(s.UserProfile);
}).ToList();
var count = sdrs.Count();
specParams.Search = specParams.Search == null ? string.Empty : specParams.Search;
sdrs = sdrs.Where(s =>
(
s.FirstName.Contains(specParams.Search) ||
s.LastName.Contains(specParams.Search) ||
s.LinkedInName.Contains(specParams.Search) ||
s.Email.Contains(specParams.Search)
) || string.IsNullOrEmpty(specParams.Search)
).Skip(skip).Take(take).ToList();
return(sdrs, count);
}
public async Task <(int, IReadOnlyList <Scheduler>)> GetSchedulers(int campaignId, int userProfileId, CommonSpecParams specParams)
{
var specGetScheduler = new GetSchedulerSpecification(specParams, campaignId, userProfileId);
var schedulers = await _unitOfWork.Repository <Scheduler>().ListAsync(specGetScheduler);
var specSchedulerCount = new GetSchedulerCountSpecification(specParams, campaignId, userProfileId);
var count = await _unitOfWork.Repository <Scheduler>().CountAsync(specSchedulerCount);
return(count, schedulers);
}
public async Task <(int, IEnumerable <UserAccountOutputDto>)> GetUserAccounts(CommonSpecParams specParams)
{
var skip = specParams.PageSize * (specParams.PageIndex - 1);
var take = specParams.PageSize;
var search = specParams.Search;
var users = await _userRepository.GetAllUsers(skip, take, search);
var usersViewModel = users.Item2.Select(s => new UserAccountOutputDto
{
Email = s.Email,
FirstName = s.FirstName,
Id = s.Id,
LastName = s.LastName,
StatusId = s.StatusId.HasValue ? s.StatusId.Value: 1
}).ToList();
return(users.Item1, usersViewModel);
}
public async Task <IActionResult> GetAllSdrAssignedToCampaign(int campaignId, [FromQuery] CommonSpecParams specParams)
{
try
{
var campaign = await _campaignService.GetCampaignById(campaignId);
if (campaign == null)
{
return(BadRequest(new ApiResponse(400, "Campaign is not existing.")));
}
var users = await _campaignAssignmentService.GetSdrsFromCampaign(campaignId, specParams);
var userProfilesMapped = _mapper.Map <IReadOnlyList <GetUserProfileOutputDto> >(users.Item1);
var count = users.Item2;
return(Ok(new Pagination <GetUserProfileOutputDto>(specParams.PageIndex, specParams.PageSize, count, userProfilesMapped)));
}
catch (Exception x)
{
return(BadRequest(new ApiResponse(400, "Something went wrong.")));
}
}
