public async Task <IActionResult> UpdatePassword(UpdatePasswordDto updatePasswordDto)
{
var user = await userManager.FindByEmailAsync(updatePasswordDto.Email);
if (user == null)
{
return(NotFound());
}
var email = HttpContext.User.FindFirstValue(ClaimTypes.Email);
if (email != updatePasswordDto.Email)
{
return(Unauthorized());
}
var result = await userManager.ChangePasswordAsync(user, updatePasswordDto.Password, updatePasswordDto.NewPassword);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest("Current password incorrect"));
}
public IActionResult UpdatePassword(UpdatePasswordDto dto)
{
if (!ModelState.IsValid)
{
TempData["error"] = "Check your input.";
return(RedirectToAction("MyProfile", new { dto.Id }));
}
try
{
updateUserPassword.Execute(dto);
TempData["success"] = "You successfully updated your profile.";
}
catch (EntityCannotBeNullException e)
{
TempData["error"] = e.Message;
}
catch (EntityMustHaveConfirmedPassword e)
{
TempData["error"] = e.Message;
}
catch (Exception e)
{
TempData["error"] = e.Message;
}
return(RedirectToAction("MyProfile", "Account", new { dto.Id }));
}
public async Task <IActionResult> UpdatePassword([FromBody] UpdatePasswordDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Model is not valid."));
}
var userId = User.GetUserId();
var dbUser = await _userManager.FindByIdAsync(userId);
if (dbUser == null)
{
return(NotFound());
}
var updatePasswordResult = await _userManager.ChangePasswordAsync(dbUser, model.OldPassword, model.Password);
if (updatePasswordResult.Succeeded)
{
return(Ok());
}
else
{
return(BadRequest(updatePasswordResult.Errors.Select(x => x.Description).FirstOrDefault()));
}
}
public IActionResult UpdatePassword([FromBody] UpdatePasswordDto dto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var userId = HttpContext.User.FindFirst(ClaimTypes.Sid)?.Value;
var success = _db.User.ChangePassword(new Guid(userId), dto.OldPassword, dto.NewPassword);
if (success)
{
return(NoContent());
}
return(BadRequest());
}
catch (Exception e)
{
_logger.LogError($"ERROR in UpdateInterface: {e.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> ChangePassword(UpdatePasswordDto passwordDto, [FromQuery(Name = "force")] bool force = false)
{
var CurrentUserId = GetTokenId();
if (CurrentUserId != passwordDto.id)
{
return(BadRequest(ree("id Invalid")));
}
passwordDto.id = CurrentUserId;
try
{
if (force && string.IsNullOrWhiteSpace(passwordDto.externalProvider))
{
return(BadRequest(ree("authentication problem, please try relogin")));
}
var editeduser = await userService.UpdatePasswordForceAsync(CurrentUserId, passwordDto.newpassword, passwordDto.externalProvider);
var applicationUser = await userService.GetUserById_include_roles_externalLogin(editeduser.Id);
var editeduserDto = mapper.Map <UserDto>(applicationUser);
var statusText = "Done";
return(Ok(ret(editeduserDto, statusText)));
}
catch (AppException ex)
{
return(BadRequest(ree(ex.Message)));
}
}
public async Task <IActionResult> UpdatePassword(string id, [FromBody] UpdatePasswordDto model)
{
var AppUser = _AppUserService.Get(id);
if (AppUser == null)
{
return(NotFound());
}
if (model == null)
{
return(BadRequest());
}
if (!_AppUserService.checkPass(id, model.OldPassword))
{
return(BadRequest("you don't have permisinn"));
}
else
{
if (!ModelState.IsValid)
{
return(new ModelValidator.UnprocessableEntityObjectResult(ModelState));
}
var upuser = await _AppUserService.UpdatePassword(id, model.NewPassword.ToString());
return(Ok("Password Updated"));
}
}
public void updatePassword(UpdatePasswordDto dto)
{
try
{
_transactionManager.beginTransaction();
var authentication = _authenticationRepo.getByType(dto.type_id, dto.type);
bool isOldPasswordCorrect = _passwordHash.ValidatePassword(dto.old_password, authentication.password);
if (!isOldPasswordCorrect)
{
throw new InvalidValueException($"Old password is incorrect.");
}
authentication.password = _passwordHash.CreateHash(dto.new_password);
_authenticationRepo.update(authentication);
_transactionManager.commitTransaction();
}
catch (Exception)
{
_transactionManager.rollbackTransaction();
throw;
}
// tx.Complete();
//}
}
public async Task <IActionResult> updatePassword([FromBody] UpdatePasswordDto updatePasswordDto)
{
if (!ModelState.IsValid)
{
return(Ok(HttpStatusCode.BadRequest));
}
return(Ok(await _auth.updatePassword(updatePasswordDto)));
}
public AuthResponseDto ValidateUpdatePassword(UpdatePasswordDto updatePasswordDto)
{
if (updatePasswordDto.OldPassword.Length < Data.PassRequiredMinLength || updatePasswordDto.OldPassword.Length > Data.PassRequiredMaxLength)
{
return new AuthResponseDto {
Message = $"Mật khẩu cũ có độ dài trong khoảng từ {Data.PassRequiredMinLength} - {Data.PassRequiredMaxLength} ký tự"
}
}
;
if (updatePasswordDto.Password.Length < Data.PassRequiredMinLength || updatePasswordDto.Password.Length > Data.PassRequiredMaxLength)
{
return new AuthResponseDto {
Message = $"Mật khẩu phải mới có độ dài trong khoảng từ {Data.PassRequiredMinLength} - {Data.PassRequiredMaxLength} ký tự"
}
}
;
if (updatePasswordDto.Password != updatePasswordDto.ConfirmPassword)
{
return new AuthResponseDto {
Message = "Mật khẩu xác nhận không khớp!"
}
}
;
var hasNumber = new Regex(@"[0-9]+");
var hasUpperChar = new Regex(@"[A-Z]+");
var hasNoneAlpha = new Regex(@"[!@#$%^&*()_+=\[{\]};:<>|./?,-]");
if (!hasNumber.IsMatch(updatePasswordDto.Password))
{
return new AuthResponseDto {
Message = "Mật khẩu mới phải có ít nhất 1 chữ số (0-9)"
}
}
;
if (!hasUpperChar.IsMatch(updatePasswordDto.Password))
{
return new AuthResponseDto {
Message = "Mật khẩu mới phải có ít nhất 1 ký tự in hoa (A-Z)"
}
}
;
if (!hasNoneAlpha.IsMatch(updatePasswordDto.Password))
{
return new AuthResponseDto {
Message = "Mật khẩu mới phải có ít nhất 1 ký tự đặc biệt"
}
}
;
return(null);
}
}
}
public IActionResult ChangePassword(int id, [FromBody] UpdatePasswordDto passwords)
{
if (passwords == null)
{
return(BadRequest());
}
var passwordUpdated = _userService.ChangePassword(id, passwords);
return(OkOrBadRequest(passwordUpdated));
}
public IActionResult UpdatePassword(UpdatePasswordDto updatePasswordData)
{
return(DoWorkAfterValidation(
() => _accountService.UpdatePassword(GetCurrentUserId(), updatePasswordData).Result
.Match <IActionResult>(
Ok,
BadRequest
)
));
}
public IActionResult Password([FromBody] UpdatePasswordDto userDto)
{
var user = _userService.UpdatePassword(userDto.UserId, userDto.Password);
if (user == null)
{
return(BadRequest(new { Message = "Failed to update password." }));
}
return(Ok(_mapper.Map <UpdateUserDto>(user)));
}
public async Task ChangePassword()
{
await ArrangeTest();
var passwordUpdateDto = new UpdatePasswordDto(
"Password123!", "Skibbitydibbity123!");
var request = passwordUpdateDto.AsStringContent();
var response = await _client.PatchAsync($"/api/users/{_user?.Id}/change-password", request);
response.EnsureSuccessStatusCode();
}
public async Task <IActionResult> UpdatePassword(UpdatePasswordDto updatePasswordDto)
{
var user = _mapper.Map <User>(updatePasswordDto);
user.PasswordHash = _passwordService.Hash(updatePasswordDto.Password);
var result = await _userService.UpdatePassword(user);
var response = new ApiResponse <bool>(result);
return(Ok(response));
}
public UpdatePasswordCommand(UpdatePasswordDto dto)
{
Dto = dto;
var validator = new Validator();
var result = validator.Validate(this);
if (!result.IsValid)
{
throw new ValidationException(result.Errors);
}
}
public async Task <ActionResult> ChangePassword(string id, UpdatePasswordDto info)
{
var result = await _userService.ChangePassword(id, info.OldPassword, info.NewPassword);
if (result.Succeeded)
{
_logger.LogInformation($"Password changed for user: {id}");
return(Ok());
}
_logger.LogInformation($"Unable to change password for user: {id}");
return(BadRequest());
}
public async Task <IActionResult> UpdatePassword([FromBody] UpdatePasswordDto dto)
{
var user = await _userManager.FindByIdAsync(dto.UserId);
var result = await _userManager.ChangePasswordAsync(user, dto.CurrentPassword, dto.NewPassword);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public UserView UpdatePassword(int userId, [FromBody] UpdatePasswordDto dto)
{
if (!ModelState.IsValid)
{
throw new BadRequestException("Invalid Request");
}
if (_userService.hasPermissions(userId))
{
return(_userService.UpdatePassword(userId, dto));
}
throw new BadRequestException("User does not have permission for this action.");
}
public async Task <IdentityResult> UpdatePassword(UpdatePasswordDto input)
{
var user = await GetCurrentUserAsync();
var updateResult = await _userManager.ChangePasswordAsync(user, input.CurrentPassword, input.NewPassword);
foreach (var error in updateResult.Errors)
{
Logger.Info($"Error Code: {error.Code}");
Logger.Info($"Error Description: {error.Description}");
}
return(updateResult);
}
public UserView UpdatePassword(int userId, UpdatePasswordDto dto)
{
if (dto.PassowrdConfirmation != dto.Password)
{
throw new BadRequestException("Passwords do not match.");
}
var user = _repo.Get(userId);
string salt = _crytpoService.GenerateSalt();
string hash = _crytpoService.GenerateHash(salt, dto.Password);
user.PasswordSalt = salt;
user.PasswordHash = hash;
_repo.Update(user);
return(_mapper.From(user));
}
public async Task ChangePassword(int id, UpdatePasswordDto updatePasswordDto)
{
var userToUpdate = await _userManager.Users.FirstOrDefaultAsync(x => x.ConsumerId == id);
if (userToUpdate == null)
{
throw new InvalidOperationException();
}
var result = await _userManager.ChangePasswordAsync(userToUpdate, updatePasswordDto.CurrentPassword, updatePasswordDto.NewPassword);
if (!result.Succeeded)
{
throw new InvalidOperationException();
}
}
public UserPasswordChangedReturnDto ChangePassword(int userId, UpdatePasswordDto passWords)
{
if (_userOperations.UserExists(userId))
{
return(null);
}
var user = _userOperations.GetUserById(userId);
if (passWords.OldPassword == passWords.NewPassword)
{
return(null);
}
var changedUser = _userOperations.ChangePassword(user, passWords.OldPassword, passWords.NewPassword);
return(changedUser == null ? null : Mapper.Map <UserPasswordChangedReturnDto>(changedUser));
}
public IActionResult changePassword(UpdatePasswordDto model)
{
if (ModelState.IsValid)
{
try
{
_authenticationService.updatePassword(model);
AlertHelper.setMessage(this, "Password change successful.", messageType.success);
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
AlertHelper.setMessage(this, ex.Message, messageType.error);
}
}
return(View(model));
}
public async Task ChangePassword_UserFound_PasswordChanged_ReturnsBadRequest()
{
// Arrange
var updatePasswords = new UpdatePasswordDto("OldPassword123!", "NewPassword123!");
var mockService = new Mock <IUserService>();
mockService.Setup(s =>
s.ChangePassword(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Failed());
// Act
_controller = new UsersController(mockService.Object, _logger);
var result = await _controller.ChangePassword("UserId", updatePasswords);
// Assert
result.Should().BeOfType <BadRequestResult>();
}
public async Task <IActionResult> UpdatePassword(UpdatePasswordDto dto)
{
_logger.LogInformation("Updating current user's password");
try
{
var currentUserId = User.GetUserId();
await _userService.UpdatePassword(currentUserId, dto.OldPassword, dto.NewPassword);
return(Ok("Password updated"));
}
catch (UpdatePasswordFailedException uex)
{
_logger.LogWarning(uex, "Update password failed");
return(BadRequest(uex.GetExceptionMessageList()));
}
}
public async Task <HttpStatusCode> updatePassword(UpdatePasswordDto updatePasswordDto)
{
User user = await _ctx.User.Where(m => m.UserId == updatePasswordDto.UserId &&
m.DeletedDate == null).FirstOrDefaultAsync();
if (user != null)
{
user.UserPassword = updatePasswordDto.UpdatedPassword;
user.UpdatedDate = DateTime.Now;
_ctx.Update(user);
int response = await _ctx.SaveChangesAsync();
if (response > 0)
{
return(HttpStatusCode.OK);
}
return(HttpStatusCode.BadRequest);
}
return(HttpStatusCode.BadRequest);
}
public async Task <ActionResult <string> > UpdateAccountPassword([FromForm] UpdatePasswordDto pass)
{
// check if this user is the same user who whant update the password
var user = await GetCurrentUserAsync(HttpContext.User);
if (user == null)
{
return(Unauthorized(new ApiResponse(401)));
}
if (pass.NewPassword == pass.ConfirmPassword)
{
IdentityResult create = await _userManager.ChangePasswordAsync(user, pass.OldPassword, pass.NewPassword);
if (create.Succeeded)
{
return(Ok("update password successfully"));
}
}
return(Ok("somthing wrong!, or old password not right"));
}
public async Task <IActionResult> ChangePassword(UpdatePasswordDto dto)
{
if (ModelState.IsValid)
{
ApplicationUser applicationUser = await _userManager.FindByIdAsync(dto.ApplicationUserId.ToString());
IdentityResult changePasswordResult =
await _userManager.ChangePasswordAsync(applicationUser, dto.CurrentPassword, dto.NewPassword);
if (changePasswordResult.Succeeded)
{
await _signInManager.RefreshSignInAsync(applicationUser);
return(Json(new { success = true }));
}
else
{
foreach (var erorr in changePasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, erorr.Description);
}
List <string> errors = new();
foreach (var modelStateValue in ModelState.Values.Where(m => m.Errors.Count > 0))
{
foreach (var item in modelStateValue.Errors)
{
errors.Add(item.ErrorMessage);
}
}
return(Json(new { success = false, errors }));
}
}
else
{
return(Json(new { success = false, errors = "An error occurred, Please try again later." }));
}
}
public IActionResult changePassword(long authentication_id)
{
try
{
var authentication = _authenticationRepo.getById(authentication_id);
if (!userIsAllowedForAction(authentication))
{
throw new Exception("You do not have permission to perform the specified action.");
}
var changePasswordDto = new UpdatePasswordDto();
changePasswordDto.type_id = authentication.type_id;
changePasswordDto.type = authentication.type;
return(View(changePasswordDto));
}
catch (Exception ex)
{
AlertHelper.setMessage(this, ex.Message, messageType.error);
return(RedirectToAction(nameof(Index)));
}
}
public async Task <IActionResult> UserUpdatePasswordAsync([FromBody] UpdatePasswordDto updatePasswordDto)
{
int userId = Convert.ToInt32(User.Identity.Name);
var user = await _repositoryWrapper.UserRepository.GetByIdAsync(userId);
if (user.Password != updatePasswordDto.OldPassword)
{
return(Ok(new { code = 1, msg = "原密码不正确！" }));
}
user.Password = updatePasswordDto.NewPassword;
await _repositoryWrapper.UserRepository.UpdateAsync(user);
if (!await _repositoryWrapper.UserRepository.SaveAsync())
{
return(BadRequest());
}
return(Ok(new { code = 0, msg = "密码修改成功！" }));
}
public async Task<IHttpActionResult> PutPassword(UpdatePasswordDto updatePasswordDto)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
IdentityResult result = await this.AppUserManager.ChangePasswordAsync(
updatePasswordDto.Id, updatePasswordDto.OldPassword,
updatePasswordDto.Password);
if (!result.Succeeded)
{
return GetErrorResult(result);
}
return Ok();
}
