public async Task <IHttpActionResult> ChangePasswordAsync([FromBody] UserChangePasswordDTO user) { if (!ModelState.IsValid) { return(BadRequest()); } if (user is null) { return(BadRequest()); } if (!user.NewPassword.Equals(user.NewPasswordConfirm)) { return(BadRequest("New password different")); } try { var result = await _userService.ChangePassword(user); if (result.IsSuccess) { return(Ok()); } else { return(BadRequest(result.Message)); } } catch (Exception ex) { return(InternalServerError(ex)); } }
public async Task <string> ChangePassword(UserChangePasswordDTO userChange) { User user = await _eFUnitOfWork.UserManager.FindByIdAsync(Convert.ToString(userChange.Id)); if (user != null) { var result = await _eFUnitOfWork.UserManager.ChangePasswordAsync(user, userChange.OldPassword, userChange.NewPassword); if (result.Succeeded) { user.Password = userChange.NewPassword; return("Пароль успішно змінено!"); } else { string ErrorMessage = ""; foreach (var error in result.Errors) { ErrorMessage += error.Description + "\n"; } return(ErrorMessage); } } return("Користувача не існує!"); }
public async Task <IActionResult> ChangePassword([FromBody] UserChangePasswordDTO userChangePassword) { try { if (userChangePassword == null) { return(StatusCode(StatusCodes.Status400BadRequest, new PasswordActionAnswer() { ServerMessage = "Argument is null" })); } if (!ModelState.IsValid) { return(StatusCode(StatusCodes.Status400BadRequest, new PasswordActionAnswer() { ServerMessage = ModelState.ToString() })); } string userEmail = this.GetCurrentUserEmail(); if (String.IsNullOrWhiteSpace(userEmail)) { return(StatusCode(StatusCodes.Status400BadRequest, new PasswordActionAnswer() { ServerMessage = "Cant get current user data" })); } var currentUser = await _UserManager.FindByEmailAsync(userEmail); if (currentUser == null) { return(StatusCode(StatusCodes.Status404NotFound, new PasswordActionAnswer() { ServerMessage = "User not found" })); } var result = await _UserManager.ChangePasswordAsync(currentUser, userChangePassword.CurrentPassword, userChangePassword.NewPassword); if (result.Succeeded) { return(StatusCode(StatusCodes.Status202Accepted, new PasswordActionAnswer() { ServerMessage = "Password changed succesfully" })); } else { return(StatusCode(StatusCodes.Status417ExpectationFailed, new PasswordActionAnswer() { ServerMessage = "Cant change password" })); } } catch (Exception e) { _Logger.LogError("Change password operation failed because of exception", e); return(StatusCode(StatusCodes.Status500InternalServerError, new PasswordActionAnswer() { ServerMessage = "Something went wrong" })); } }
public async Task <ActionResult> ChangePassword([FromBody] UserChangePasswordDTO password) { var request = new ChangePasswordCommand(User.Identity?.Name, password); var response = await _mediator.Send(request); return(response.Match <ActionResult>( ok => Ok(), invalidCredentials => BadRequest("Invalid old password") )); }
public async Task <Result> ChangePassword(UserChangePasswordDTO user) { var usermodel = _mapper.Map <UserChangePasswordDTO, UserChangePassword>(user); try { var result = await _usersContext.ChangePassword(usermodel); return(result ? Result.Ok() : Result.Fail("PasswordChange Error")); } catch { return(Result.Fail("Error in change password")); } }
public async Task ChangePassword(UserChangePasswordDTO userChangePasswordDTO, int userId) { var userEntity = await _context.Users.SingleOrDefaultAsync(u => u.Id == userId); if (!SecurityHelper.ValidatePassword(userChangePasswordDTO.Password, userEntity.PasswordHash, userEntity.PasswordSalt)) { throw new InvalidUsernameOrPasswordException("wrong password"); } var salt = SecurityHelper.GetRandomBytes(); userEntity.PasswordSalt = Convert.ToBase64String(salt); userEntity.PasswordHash = SecurityHelper.HashPassword(userChangePasswordDTO.NewPassword, salt); await _context.SaveChangesAsync(); }
//-> Change Password public async Task<UserViewDTO> ChangePassword(UserChangePasswordDTO changePasswordDTO) { var user = (UserViewDTO)HttpContext.Current.Session["user"]; var password = CryptingHelper.EncryptString(changePasswordDTO.password); var checkRecord = await db.tblUsers.FirstOrDefaultAsync(x => x.deleted == null && x.id == user.id && x.password == password); if (checkRecord == null) throw new HttpException((int)HttpStatusCode.BadRequest, ConstantHelper.INCORRECT_PASSWORD); if(changePasswordDTO.newPassword != changePasswordDTO.comfirmPassword) throw new HttpException((int)HttpStatusCode.BadRequest, ConstantHelper.PASSWORD_DOES_NOT_MATCH); checkRecord.password = CryptingHelper.EncryptString(changePasswordDTO.newPassword); await db.SaveChangesAsync(); return await SelectByID(checkRecord.id); }
public ActionResult ChangePassword([FromBody] UserChangePasswordDTO userDTO) { if (ModelState.IsValid) { var user = _userRepository.Get(userDTO.Email); if (user == null) { return(NotFound("Usuário não encontrado.")); } if (!_userRepository.CheckPassword(user, userDTO.PasswordCurrent)) { return(NotFound("Senha atual inválida.")); } user.PasswordHash = userDTO.PasswordNew; var result = _userRepository.ChangePassword(user, userDTO.PasswordNew); if (!result.Succeeded) { List <string> errors = new List <string>(); foreach (var error in result.Errors) { errors.Add(error.Description); } return(UnprocessableEntity(errors)); } else { return(Ok("Senha alterada com sucesso.")); } } else { return(UnprocessableEntity(ModelState)); } }
public void UpdatePwd(long userId, UserChangePasswordDTO dto) { User user = _context.Users.Where(p => p.Id == userId).SingleOrDefault(); if (user == null) { throw new NotImplementedException(); } string oldPasswordHash = CommonHelper.CalcMD5(user.PassWordSalt + dto.OldPassw0rd); if (oldPasswordHash != user.PassWordHash) { throw new NotImplementedException(); } user.PassWordSalt = CommonHelper.CreateVerifyCode(5); string pwdHash = CommonHelper.CalcMD5(user.PassWordSalt + dto.NewPassw0rd); user.PassWordHash = pwdHash; _context.SaveChanges(); }
public async Task <IActionResult> ChangePassword(UserChangePasswordDTO userChangePasswordDto) { if (ModelState.IsValid) { var nameOfCurrentUser = HttpContext.User.Identity.Name; var user = await _userManager.FindByNameAsync(nameOfCurrentUser); if (user != null) { IdentityResult result = await _userManager.ChangePasswordAsync(user, userChangePasswordDto.OldPassword, userChangePasswordDto.NewPassword); if (result.Succeeded) { await _emailService.SendAsync(ChangePasswordSettings.subject, ChangePasswordSettings.GetMessage(user.Email, userChangePasswordDto.NewPassword), user.Email); return(RedirectToAction("Index", "Home")); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } else { ModelState.AddModelError(string.Empty, "Користувач незнайдений"); } } else { ModelState.AddModelError(string.Empty, "Неправильно введені дані"); } return(PartialView(userChangePasswordDto)); }
public async Task <JsonResult> ChangePassword(UserChangePasswordDTO changePasswordDTO) { try { if (!ModelState.IsValid) { throw new HttpException((int)HttpStatusCode.BadRequest, ConstantHelper.KEY_IN_REQUIRED_FIELD); } Response.StatusCode = 200; return(Json(await handler.ChangePassword(changePasswordDTO), JsonRequestBehavior.AllowGet)); } catch (HttpException ex) { if (ex.Message == ConstantHelper.INCORRECT_PASSWORD || ex.Message == ConstantHelper.PASSWORD_DOES_NOT_MATCH || ex.Message == ConstantHelper.KEY_IN_REQUIRED_FIELD) { Response.StatusCode = 400; } else { Response.StatusCode = 500; } return(Json(ex.Message, JsonRequestBehavior.AllowGet)); } }
public async Task UpdatePassword([FromBody] UserChangePasswordDTO userChangePasswordDTO) { var userId = this.GetUserIdFromToken(); await _userService.ChangePassword(userChangePasswordDTO, userId); }
public ChangePasswordCommand(string?userLogin, UserChangePasswordDTO changePasswordDTO) : base(userLogin) { ChangePasswordDTO = changePasswordDTO; }
public async Task <IActionResult> ChangePassword([FromBody] UserChangePasswordDTO user) { return(Ok(await _userService.ChangePassword(user))); }