public async Task AssignSdrToManager(AssignSdrToManagerInputDto request, string userId)
        {
            var sdrGroupingRequest = new SdrGrouping {
                CreatedBy   = userId,
                CreatedDate = DateTime.UtcNow,
                ManagerId   = request.ManagerEmployeeId,
                SdrId       = request.SdrEmployeeId
            };

            _unitOfWork.Repository <SdrGrouping>().Add(sdrGroupingRequest);
            await _unitOfWork.Complete();
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> AssignSdrToManager([FromBody] AssignSdrToManagerInputDto request)
        {
            try
            {
                var user = await _userManager.FindByEmailFromClaimsPrinciple(HttpContext.User);

                var validationResponse = await _sdrGroupingService.ValidateAssignSdrToManagerInput(request);

                if (!validationResponse.IsSuccess)
                {
                    return(BadRequest(new ApiResponse(validationResponse.StatusCode, validationResponse.Message)));
                }

                await _sdrGroupingService.AssignSdrToManager(request, user.Id.ToString());

                return(Ok(new ApiResponse(200, "Success")));
            }
            catch
            {
                return(BadRequest(new ApiResponse(400, "Something went wrong.")));
            }
        }
        public async Task <ValidationOutputDto> ValidateAssignSdrToManagerInput(AssignSdrToManagerInputDto request)
        {
            //Check if Manager UserprofileId exists
            var userManagerSpecs   = new GetUserProfileWithDetailsByIdSpecification(request.ManagerEmployeeId);
            var userprofileManager = await _unitOfWork.Repository <UserProfile>().GetEntityWithSpec(userManagerSpecs);

            if (userprofileManager == null)
            {
                return new ValidationOutputDto {
                           IsSuccess  = false,
                           Message    = "Manager is not existing.",
                           StatusCode = 400
                }
            }
            ;

            //Check if Role is Manager
            var roleManager = (await _userManager.GetRolesAsync(userprofileManager.AppUser)).First();

            if (roleManager != UserRole.manager.ToString())
            {
                return new ValidationOutputDto
                       {
                           IsSuccess  = false,
                           Message    = "The Manager Id provided is not assigned as role Manager.",
                           StatusCode = 400
                       }
            }
            ;

            //Check if Sdr UserprofileId exists
            var userSdrSpecs   = new GetUserProfileWithDetailsByIdSpecification(request.SdrEmployeeId);
            var userprofileSdr = await _unitOfWork.Repository <UserProfile>().GetEntityWithSpec(userSdrSpecs);

            if (userprofileSdr == null)
            {
                return new ValidationOutputDto
                       {
                           IsSuccess  = false,
                           Message    = "Sdr is not existing.",
                           StatusCode = 400
                       }
            }
            ;

            //Check if Role is SDR
            var roleSdr = (await _userManager.GetRolesAsync(userprofileSdr.AppUser)).First();

            if (roleSdr != UserRole.sdr.ToString())
            {
                return new ValidationOutputDto
                       {
                           IsSuccess  = false,
                           Message    = "The Sdr Id provided is not assigned as role SDR.",
                           StatusCode = 400
                       }
            }
            ;

            return(new ValidationOutputDto
            {
                IsSuccess = true,
                Message = string.Empty,
                StatusCode = 200
            });
        }