/// <summary>
/// User update password
/// </summary>
/// <param name="websiteId"></param>
/// <param name="userId"></param>
/// <param name="userUpdatePasswordModel"></param>
/// <returns></returns>
public async Task UpdatePassword(int websiteId, int userId, UserUpdatePasswordModel userUpdatePasswordModel)
{
if (userUpdatePasswordModel.NewPassword == null ||
userUpdatePasswordModel.NewPassword.Length < Constants.Utility.PasswordMinLength)
{
throw new ValidationException(Constants.MessageResponse.NewPasswordNotMeetExpected);
}
var userRepository = unitOfWork.GetRepository <User>();
var user = await userRepository.FindByAsync(x => x.Id == userId &&
x.WebsiteId == websiteId);
if (user == null)
{
throw new NotFoundException(string.Format(
Constants.MessageResponse.NotFoundError, nameof(User), nameof(userUpdatePasswordModel.Id)));
}
var isValid = Security.ValidatePassword(user.Email, userUpdatePasswordModel.OldPassword, user.Password);
if (!isValid)
{
throw new ValidationException(string.Format(Constants.MessageResponse.OldPasswordIncorrect));
}
user.Password = Security.CreateHashPassword(user.Email, userUpdatePasswordModel.NewPassword);
user.UpdatedDate = DateTime.UtcNow;
userRepository.Update(user);
await unitOfWork.CommitAsync();
}
public async Task <bool> ChangePassword(int id, UserUpdatePasswordModel model, UserIdentity <int> issuer)
{
var user = await _userRepository.FindByUserIdAsync(id);
if (user == null)
{
return(false);
}
var result = await _userManagement.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (!result.Succeeded)
{
return(false);
}
user.UpdateBy(issuer);
_userRepository.Update(user);
await _uow.SaveChangesAsync();
EmailTemplate emailTemplate = _emailTemplateRepository.GetEmailTemplateByName("ChangeUserPasswordEmail");
emailTemplate.EmailContent = emailTemplate.EmailContent.Replace("#email", user.Email);
emailTemplate.EmailContent = emailTemplate.EmailContent.Replace("#username", user.UserName);
await _emailSender.SendEmailAsync(user.Email, emailTemplate.EmailSubject, emailTemplate.EmailContent, true);
return(true);
}
public ActionResult Manage(UserUpdatePasswordModel model)
{
if (ModelState.IsValid)
{
var userProfile = base.db.Users.FirstOrDefault(u => u.Name == User.Identity.Name);
if (userProfile != null)
{
var hash = General.HashString(model.CurrentPassword + userProfile.Salt.ToString());
if (hash == userProfile.Password)
{
hash = General.HashString(model.NewPassword + userProfile.Salt.ToString());
userProfile.Password = hash;
db.Entry(userProfile).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
}
ModelState.AddModelError("", Resources.Global.Account_Login_LoginFailed);
}
return(View(model));
}
public async Task <IActionResult> UpdatePassword([FromBody] UserUpdatePasswordModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(Json(await _managerUserControl.UpdatePassword(model)));
}
public async Task <bool> UpdatePassword(UserUpdatePasswordModel model)
{
var currentUser = await _repositoryUser.Get(_userId);
if (!await _managerUser.CheckPasswordAsync(currentUser, model.Password))
{
_eAccessDenied("Incorrect password");
}
var result = await _managerUser.ChangePasswordAsync(currentUser, model.Password, model.NewPassword);
return(result.Succeeded);
}
public ActionResult UpdatePassword()
{
var user = _session.Load <User>(_executionContext.UserId);
if (user != null)
{
UserUpdatePasswordModel model = new UserUpdatePasswordModel()
{
Username = user.Username
};
return(View(model));
}
return(RedirectToAction("Index", "Home"));
}
public void TestUpdatePasswordAsync_OldPasswordNotEqual_ShouldThrowValidationException()
{
var websiteId = 1;
var userId = 1;
var userUpdatePasswordModel = new UserUpdatePasswordModel()
{
OldPassword = "******",
NewPassword = "******",
WebsiteId = 1
};
ValidationException ex = Assert.Throws <ValidationException>(() => userService.UpdatePassword(websiteId, userId, userUpdatePasswordModel).GetAwaiter().GetResult());
Assert.AreEqual(
Constants.MessageResponse.OldPasswordIncorrect,
ex.Message);
}
public IActionResult UpdatePassword([FromBody] UserUpdatePasswordModel model)
{
int.TryParse(HttpContext.User.Identity.Name, out var id);
int.TryParse(_config["security:pwdsize"], out var size);
var salt = PasswordService.GenerateSalt(size);
var user = _dataService.GetUserById(id);
var pwd = PasswordService.HashPassword(model.Password, salt, size);
var updated = _dataService.UpdatePassword(id, pwd, salt);
if (updated == false)
{
return(BadRequest());
}
return(Ok());
}
public void TestUpdatePasswordAsync_ValidInput_ShouldNewPasswordChanged()
{
var websiteId = 1;
var userId = 1;
var userUpdatePasswordModel = new UserUpdatePasswordModel()
{
OldPassword = "******",
NewPassword = "******",
WebsiteId = 1
};
Assert.DoesNotThrowAsync(() => userService.UpdatePassword(websiteId, userId, userUpdatePasswordModel));
var userUpdated = users.SingleOrDefault(x => x.Id == userId && x.WebsiteId == websiteId);
var isValid = Security.ValidatePassword(userUpdated.Email, userUpdatePasswordModel.NewPassword, userUpdated.Password);
Assert.IsTrue(isValid);
}
public void TestUpdatePasswordAsync_UserIdNotExisted_ShouldThrowNotFoundException()
{
var websiteId = 1;
var userId = 10;
var userUpdatePasswordModel = new UserUpdatePasswordModel()
{
OldPassword = "******",
NewPassword = "******",
WebsiteId = 1
};
NotFoundException ex = Assert.Throws <NotFoundException>(() => userService.UpdatePassword(websiteId, userId, userUpdatePasswordModel).GetAwaiter().GetResult());
Assert.AreEqual(
string.Format(
Constants.MessageResponse.NotFoundError, nameof(User), nameof(userUpdatePasswordModel.Id)),
ex.Message);
}
public ActionResult UpdatePassword(UserUpdatePasswordModel model)
{
var user = _session.Load <User>(_executionContext.UserId);
if (!Encryption.Verify(model.OldPassword, user.Password))
{
ModelState.AddModelError("OldPassword", "Incorrect original password");
return(View("UpdatePassword", model));
}
if (model.NewPassword != model.ConfirmNewPassword)
{
ModelState.AddModelError("ConfirmNewPassword", "New password confirmation incorrect");
return(View("UpdatePassword", model));
}
user.ChangePassword(Encryption.HashPassword(model.NewPassword));
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> UpdatePassword(UserUpdatePasswordModel userUpdatePasswordModel)
{
await userService.UpdatePassword(this.WebsiteId, this.UserId, userUpdatePasswordModel);
return(Ok(new ApiResponse <UserUpdatePasswordModel>()));
}