public async Task <BaseResponse> AddUser(UserRegisterRequest register)
        {
            User         user           = new User();
            BaseResponse baseResponse   = new BaseResponse();
            string       encodePassword = EncodeComparePassword.GetMd5Hash(register.Password);

            try
            {
                user.UserName        = register.UserName;
                user.FirstName       = register.FirstName;
                user.LastName        = register.LastName;
                user.Gender          = register.Gender;
                user.DateOfBirth     = register.DateOfBirth;
                user.Designation     = register.Designation;
                user.Phone           = register.Phone;
                user.AlternateNumber = register.AlternateNumber;
                user.Email           = register.Email;
                user.Password        = encodePassword;
                user.OfficialEmail   = register.OfficialEmail;
                user.Skype           = register.Skype;
                user.PAN             = register.PAN;
                user.BloodGroup      = register.BloodGroup;
                user.DateOfJoining   = register.DateOfjoining;
                user.DateOfLeaving   = register.DateOfLeaving;
                user.MediaId         = register.MediaId;
                user.IsActive        = true;
                user.CreatedBy       = "Admin";
                user.CreatedOn       = DateTime.Now;
                user.IsApproved      = register.IsApproved;
                ObjContext.Users.Add(user);
                await ObjContext.SaveChangesAsync();

                if (register.addUserRoles.Count > 0)
                {
                    var getUserId = ObjContext.Users.Where(u => u.Email == register.Email).FirstOrDefault();

                    for (int i = 0; i <= register.addUserRoles.Count - 1; i++)
                    {
                        UserRole userRole = new UserRole();

                        userRole.Userld    = getUserId.UserId;
                        userRole.RoleId    = register.addUserRoles[i].RoleId;
                        userRole.IsActive  = true;
                        userRole.CreatedBy = "Admin";
                        userRole.CreatedOn = DateTime.Now;
                        ObjContext.UserRole.Add(userRole);
                        await ObjContext.SaveChangesAsync();
                    }
                }

                baseResponse.Status  = true;
                baseResponse.Message = Constants.USER_PROFILE_CREATED;
            }
            catch (Exception ex)
            {
                baseResponse.Status  = false;
                baseResponse.Message = ex.Message;
            }
            return(baseResponse);
        }
 public MainResponse Authenticate(UserLoginRequest login)
 {
     try
     {
         string encodePassword = EncodeComparePassword.GetMd5Hash(login.Password);
         var    user           = _userRepository.GetSingle(x => x.Email == login.Email.ToLower() && x.Password == encodePassword && x.IsApproved == true);
         var    data           = _userRepository.LoginUser(user.UserId);
         if (data != null)
         {
             var userResponse = _mapper.Map <UserResponse>(data);
             _response.userResponse = userResponse;
             _response.Status       = true;
         }
         else
         {
             _response.Message = Constants.LOGIN_FAILURE_MSG;
         }
     }
     catch (Exception ex)
     {
         _logger.LogError(ex, ex.Message);
         _response.Status  = false;
         _response.Message = Constants.DEFAULT_ERROR_MSG;
     }
     return(_response);
 }
        public async Task <MainResponse> RegisterUser(UserRegisterRequest register)
        {
            try
            {
                var isEmailExist = _userRepository.GetSingle(x => x.Email == register.Email);
                if (isEmailExist != null)
                {
                    _response.Message = Constants.EMAIL_ALREADY_EXIST;
                    return(_response);
                }
                if (register.UserName != null && register.UserName != "")
                {
                    _baseResponse = await _userRepository.AddUser(register);

                    _response.Status  = _baseResponse.Status;
                    _response.Message = _baseResponse.Message;
                    return(_response);
                }
                var user = _mapper.Map <User>(register);
                user.Password  = EncodeComparePassword.GetMd5Hash(user.Password);
                user.CreatedOn = DateTime.Now;
                //user.CreatedBy = register.Username;
                user.IsActive   = true;
                user.IsDeleted  = false;
                user.IsApproved = false;
                var data = await _userRepository.AddAsync(user);

                if (data != null)
                {
                    var userResponse = _mapper.Map <UserResponse>(data);
                    _response.userResponse = userResponse;
                    _response.Status       = true;
                    _response.Message      = Constants.USER_REGISTERED;
                }
                else
                {
                    _response.Message = Constants.LOGIN_FAILURE_MSG;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                _response.Status  = false;
                _response.Message = Constants.DEFAULT_ERROR_MSG;
            }
            return(_response);
        }
        public async Task <MainResponse> ChangePassword(ChangePasswordRequest changePasswordRequest)
        {
            try
            {
                var user = _userRepository.GetSingle(x => x.Email == changePasswordRequest.Email && x.IsDeleted == false);

                if (user != null)
                {
                    user.Password = EncodeComparePassword.GetMd5Hash(changePasswordRequest.NewPassword);
                    //user.ModifiedBy = changePasswordRequest.UserName;
                    user.ModifiedOn = DateTime.Now;
                    var data = await _userRepository.UpdateAsync(user);

                    if (data != null)
                    {
                        var userResponse = _mapper.Map <UserResponse>(data);
                        _response.userResponse = userResponse;
                        _response.Status       = true;
                        _response.Message      = Constants.PASSWORD_CHANGED;
                    }
                    else
                    {
                        _response.Message = Constants.LOGIN_FAILURE_MSG;
                    }
                }
                else
                {
                    _response.Status  = false;
                    _response.Message = Constants.NO_RECORD_FOUND;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                _response.Status  = false;
                _response.Message = Constants.DEFAULT_ERROR_MSG;
            }
            return(_response);
        }