public async Task <IActionResult> UpdatePassword(UpdatePasswordModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("_UpdatePassword", model));
}
if (model.NewPassword != model.ConfirmPassword)
{
ModelState.AddModelError("ConfirmPassword", "Must match new password");
}
var result = await _identityService.UpdatePassword(model.UserId, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(new EmptyResult());
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(PartialView("_UpdatePassword", model));
}
/// <summary>
/// updates password
/// </summary>
/// <param name="pwd"> Update Password Model </param>
/// <returns> true or false </returns>
public bool UpdatePassword(UpdatePasswordModel pwd)
{
using (var _ctx = new ChinmayaEntities())
{
var userEmail = _ctx.Users.Where(r => r.Email == pwd.Email && r.Password == pwd.OldPassword).FirstOrDefault();
if (userEmail == null)
{
return(false);
}
else if (userEmail != null)
{
userEmail.Password = pwd.NewPassword;
}
try
{
_ctx.Entry(userEmail).State = EntityState.Modified;
_ctx.SaveChanges();
return(true);
}
catch
{
throw;
}
}
}
public async Task <ActionResult> ChangePassword(UpdatePasswordModel Info)
{
ToastModel tm = new ToastModel();
string role = await _common.GetUserRoleName(User.Identity.Name);
if (ModelState.IsValid)
{
UpdatePasswordModel passwordModel = new UpdatePasswordModel();
passwordModel.Email = User.Identity.Name;
EncryptDecrypt objEncryptDecrypt = new EncryptDecrypt();
passwordModel.OldPassword = objEncryptDecrypt.Encrypt(Info.OldPassword, WebConfigurationManager.AppSettings["ServiceAccountPassword"]);
EncryptDecrypt objEncryptDecrypt1 = new EncryptDecrypt();
passwordModel.NewPassword = objEncryptDecrypt.Encrypt(Info.NewPassword, WebConfigurationManager.AppSettings["ServiceAccountPassword"]);
HttpResponseMessage userResponseMessage = await Utility.GetObject("/api/User/UpdatePassword", passwordModel, true);
bool status = await Utility.DeserializeObject <bool>(userResponseMessage);
if (status == true)
{
tm.IsSuccess = true;
tm.Message = "Password updated successfully";
}
else
{
tm.IsSuccess = false;
tm.Message = "Failed to update Password"; //Old password Does not match
}
return(Json(tm));
}
return(PartialView("_ChangePassword"));
}
public async Task <ActionResult> ChangePassword(UpdatePasswordModel Info, string nextBtn)
{
ToastModel tm = new ToastModel();
if (nextBtn != null)
{
if (ModelState.IsValid)
{
UpdatePasswordModel passwordModel = new UpdatePasswordModel();
passwordModel.Email = User.Identity.Name;
EncryptDecrypt objEncryptDecrypt = new EncryptDecrypt();
passwordModel.OldPassword = objEncryptDecrypt.Encrypt(Info.OldPassword, WebConfigurationManager.AppSettings["ServiceAccountPassword"]);
EncryptDecrypt objEncryptDecrypt1 = new EncryptDecrypt();
passwordModel.NewPassword = objEncryptDecrypt.Encrypt(Info.NewPassword, WebConfigurationManager.AppSettings["ServiceAccountPassword"]);
HttpResponseMessage userResponseMessage = await Utility.GetObject("/api/User/UpdatePassword", passwordModel, true);
bool status = await Utility.DeserializeObject <bool>(userResponseMessage);
if (status == true)
{
tm.IsSuccess = true;
tm.Message = "Password updated successfully";
}
else
{
tm.IsSuccess = false;
tm.Message = "Password not updated";
}
return(Json(tm));
}
}
return(RedirectToAction("MyAccount", "Account"));
}
public void UpdateUserPassword_InvalidPasswordModel_ExpectArgumentException(int id, string oldPassword, string newPassword, string errorExpected)
{
// arrange
User user = new User()
{
ID = id,
Username = "******",
UserRole = "user"
};
UpdatePasswordModel model = new UpdatePasswordModel()
{
OldPassword = oldPassword,
NewPassword = newPassword
};
userDatabase.Add(user.ID, user);
UserService service = new UserService(repoMock.Object, authMock.Object, validatorMock.Object);
// act + assert
var ex = Assert.Throws <ArgumentException>(() => service.UpdatePassword(id, model));
Assert.Equal(errorExpected, ex.Message);
validatorMock.Verify(validator => validator.ValidateCreateUser(It.Is <string>(un => un == user.Username), It.Is <string>(pw => pw == newPassword), It.Is <string>(ur => ur == user.UserRole)), Times.Never);
authMock.Verify(validator => validator.ValidateLogin(It.Is <User>(u => u == user), It.IsAny <LoginInputModel>()), Times.Never);
repoMock.Verify(repo => repo.UpdateUser(It.Is <User>(u => u == user)), Times.Never);
}
public async Task <ActionResult> UpdatePassword(UpdatePasswordModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("_UpdatePassword", new UpdatePasswordModel()));
}
if (!await IsSettingsUnlocked())
{
ModelState.AddModelError("Error", Resources.User.securityUnlockTokenExpiredError);
return(PartialView("_UpdatePassword", new UpdatePasswordModel()));
}
var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("Error", error);
}
return(PartialView("_UpdatePassword", new UpdatePasswordModel()));
}
await UserManager.UpdateSecurityStampAsync(User.Identity.GetUserId());
ModelState.AddModelError("Success", Resources.User.securityPasswordUpdatedMessage);
return(PartialView("_UpdatePassword", new UpdatePasswordModel()));
}
public async Task <Response> UpdatePasswordAsync(UpdatePasswordModel model)
{
Uri uri = new Uri(string.Format(Constants.UpdateUserPassUrl, string.Empty));
try
{
string json = JsonSerializer.Serialize <UpdatePasswordModel>(model, serializerOptions);
StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
client.DefaultRequestHeaders.Add("Authorization", $"Bearer {this.BearerToken}");
HttpResponseMessage response = null;
response = await client.PatchAsync(uri, content);
string jsonresponse = await response.Content.ReadAsStringAsync();
Response response2 = JsonSerializer.Deserialize <Response>(jsonresponse, serializerOptions);
if (response.IsSuccessStatusCode)
{
Debug.WriteLine(@"\user password successfully saved.");
}
return(response2);
}
catch (Exception ex)
{
Debug.WriteLine(@"\tERROR {0}", ex.Message);
return(new Response()
{
Status = Constants.Status.Error, Message = Constants.APIMessages.ErrorOnUpdate
});
}
}
public IActionResult ChangePassword(UpdatePasswordModel model)
{
// Assume the user is not authorized
IActionResult result = Unauthorized();
// Get the user by username
var user = userDao.GetUser(model.Username);
// If we found a user and the password has matches
if (user != null && passwordHasher.VerifyHashMatch(user.Password, model.Password, user.Salt))
{
// Update the password to the new password
// Generate a password hash
var passwordHash = passwordHasher.ComputeHash(model.NewPassword);
// Create a user object
var userUpdated = new User {
Password = passwordHash.Password, Salt = passwordHash.Salt, Role = user.Role, Username = model.Username, Id = user.Id
};
// Update the password and the salt
userDao.UpdateUser(userUpdated);
// Generate an authentication token
var token = tokenGenerator.GenerateToken(user.Username, user.Role);
// Switch to 200 OK
result = Ok(token);
}
return(result);
}
public void UpdateUserPassword_ValidPasswordModel(int id, string oldPassword, string newPassword)
{
// arrange
User user = new User()
{
ID = id,
Username = "******",
UserRole = "user"
};
UpdatePasswordModel model = new UpdatePasswordModel()
{
OldPassword = oldPassword,
NewPassword = newPassword
};
userDatabase.Add(user.ID, user);
UserService service = new UserService(repoMock.Object, authMock.Object, validatorMock.Object);
// act + assert
service.UpdatePassword(id, model);
validatorMock.Verify(validator => validator.ValidateCreateUser(It.Is <string>(un => un == user.Username), It.Is <string>(pw => pw == newPassword), It.Is <string>(ur => ur == user.UserRole)), Times.Once);
authMock.Verify(validator => validator.ValidateLogin(It.Is <User>(u => u == user), It.IsAny <LoginInputModel>()), Times.Once);
repoMock.Verify(repo => repo.UpdateUser(It.Is <User>(u => u == user)), Times.Once);
}
public async Task <IActionResult> UpdatePassword([FromBody] UpdatePasswordModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(NotFound());
}
else if (await userManager.CheckPasswordAsync(user, model.Password))
{
var result = await userManager.ChangePasswordAsync(user, model.Password, model.NewPassword);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = Status.Error, Message = APIMessages.ErrorOnPasswordChange
}));
}
return(Ok(new Response {
Status = Status.Success, Message = APIMessages.Success
}));
}
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = Status.Error, Message = APIMessages.ErrorOnPasswordCheck
}));
}
public async Task <IActionResult> ChangeNewPassword(UpdatePasswordModel request)
{
if (ModelState.IsValid is false)
{
return(PartialView("_ChangePassword"));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
var changePasswordResult = await _userManager.ChangePasswordAsync(user, request.OldPassword, request.NewPassword);
if (changePasswordResult.Succeeded is false)
{
foreach (var error in changePasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(PartialView("_ChangePassword"));
}
await _signInManager.RefreshSignInAsync(user);
var url = Url.Action("Index", "Dentist");
return(Json(new { success = true, url }));
}
public eErrors CheckPasswordValidation(UpdatePasswordModel i_Model)
{
eErrors error = eErrors.None;
try
{
using (MyDiveEntities MyDiveDB = new MyDiveEntities())
{
ObjectResult <string> serverResult = MyDiveDB.stp_GetUserPassword(i_Model.UserId);
List <string> userPass = serverResult.ToList();
if (userPass.Count > 0)
{
if (!userPass[0].Equals(i_Model.OldPassword))
{
error = eErrors.PasswordAreNotEqual;
}
}
}
}
catch (Exception ex)
{
Logger.Instance.Notify(ex.StackTrace, eLogType.Error, JsonConvert.SerializeObject(i_Model));
}
return(error);
}
public async Task <IActionResult> UpdatePassword(int id, UpdatePasswordModel model)
{
if (id != model.Id)
{
return(BadRequest("Something went wrong. There was an inconsistency in the data."));
}
try
{
var user = await _userRepo.FindAsync(id);
user.Password = model.Password;
await _userRepo.UpdateAsync(user);
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void UpdateUserPassword_WhenPreviousPasswordDoesNotMatchInRecords_ReturnIncorrectPasswordError()
{
UpdatePasswordModel input = new UpdatePasswordModel()
{
UserName = "******",
NewPassword = "******", //password1
PreviousPassword = "******" //password
};
Mock <IUserDataAccess> user = new Mock <IUserDataAccess>();
Mock <IDailyTimeInDataAccess> timeIn = new Mock <IDailyTimeInDataAccess>();
Mock <IDailyTimeOutDataAccess> timeOut = new Mock <IDailyTimeOutDataAccess>();
user.Setup(x => x.GetUser(input.UserName)).Returns(new User()
{
UserName = "******",
UserPassword = "******"
});
ILoginBusinessRules app = new LoginBusinessRules(user.Object, timeIn.Object, timeOut.Object);
var output = app.UpdateUserPassword(input);
Assert.AreEqual("Previous password does not match.", output);
}
public void UpdateUserPassword_WhenInputsAreCorrect_ReturnsQuerySuccessMessage()
{
UpdatePasswordModel input = new UpdatePasswordModel()
{
UserName = "******",
NewPassword = "******", //password1
PreviousPassword = "******" //password
};
Mock <IUserDataAccess> user = new Mock <IUserDataAccess>();
Mock <IDailyTimeInDataAccess> timeIn = new Mock <IDailyTimeInDataAccess>();
Mock <IDailyTimeOutDataAccess> timeOut = new Mock <IDailyTimeOutDataAccess>();
user.Setup(x => x.UpdatePassword(10000, It.IsAny <string>())).Returns("User record updated.");
user.Setup(x => x.GetUser(input.UserName)).Returns(new User()
{
UserKey = 10000,
UserName = "******",
UserPassword = "******"
});
ILoginBusinessRules app = new LoginBusinessRules(user.Object, timeIn.Object, timeOut.Object);
var output = app.UpdateUserPassword(input);
Assert.AreEqual("User record updated.", output);
}
public async Task <IActionResult> UpdatePassword(UpdatePasswordModel model)
{
if (string.IsNullOrEmpty(model.Username))
{
return(new JsonResult(new { success = false, message = "Username is required" }));
}
if (string.IsNullOrEmpty(model.CurrentPassword))
{
return(new JsonResult(new { success = false, message = "Current Password is required" }));
}
if (string.IsNullOrEmpty(model.NewPassword))
{
return(new JsonResult(new { success = false, message = "New Password is required" }));
}
var foundUser = await _userManager.FindByNameAsync(model.Username);
if (foundUser != null)
{
var result = await _userManager.ChangePasswordAsync(foundUser, model.CurrentPassword, model.NewPassword);
if (result.Succeeded)
{
return(new JsonResult(new { success = true }));
}
else
{
return(new JsonResult(new { success = false, message = "Unable to update password.", identityErrors = result.Errors }));
}
}
return(new JsonResult(new { success = false, message = "User does not exist." }));
}
public async Task <IActionResult> PasswordReset([FromBody] UpdatePasswordModel model)
{
if (!model.Key.HasValue || string.IsNullOrEmpty(model.Password))
{
return(BadRequest());
}
await _context.CleanPasswordResets();
var reset = await _context.PasswordResets.FirstOrDefaultAsync(pr => pr.Key.Equals(model.Key.Value));
if (reset == null || reset.ExpiryDate < DateTime.UtcNow)
{
return(NotFound());
}
try
{
await _userService.UpdatePassword(reset.RegisteredUserId, model.Password);
}
catch (Exception)
{
return(StatusCode(500));
}
return(NoContent());
}
public IActionResult UpdatePassword()
{
//展示页面
if (!Request.Method.ToUpper().Equals("POST", StringComparison.OrdinalIgnoreCase) || !Request.HasFormContentType)
{
// 权限和菜单
UpdatePasswordModel model = new UpdatePasswordModel();
var layoutModel = this.GetLayoutModel();
if (layoutModel != null)
{
layoutModel.ToT(ref model);
}
return(View(model));
}
else
{
//修改密码
var msg = new Message(10, "修改密码失败！");
string oldPassword = Request.Form["oldPassword"];
string password = Request.Form["password"];
string rePassword = Request.Form["rePassword"];
var adminToken = CMSAdminCookie.GetAdiminCookie();
var admin = CMSAdminBO.GetAdminByUserName(adminToken.UserName);
if (admin != null || admin.ID > 0)
{
msg = CMSAdminBO.UpdatePasswordByID(admin.ID, oldPassword, password, rePassword);
}
return(new JsonResult(msg));
}
}
public void UpdateUserPassword_NotStoredUser_ExpectArgumentException()
{
// arrange
User user = new User()
{
ID = 1,
Username = "******",
UserRole = "user"
};
UpdatePasswordModel model = new UpdatePasswordModel()
{
OldPassword = "******",
NewPassword = "******"
};
UserService service = new UserService(repoMock.Object, authMock.Object, validatorMock.Object);
// act + assert
var ex = Assert.Throws <ArgumentException>(() => service.UpdatePassword(user.ID, model));
Assert.Equal("User with such ID does not exist", ex.Message);
validatorMock.Verify(validator => validator.ValidateCreateUser(It.Is <string>(un => un == user.Username), It.Is <string>(pw => pw == model.NewPassword), It.Is <string>(ur => ur == user.UserRole)), Times.Never);
repoMock.Verify(repo => repo.GetUserByID(It.Is <int>(ID => ID == user.ID)), Times.Once);
authMock.Verify(validator => validator.ValidateLogin(It.Is <User>(u => u == user), It.IsAny <LoginInputModel>()), Times.Never);
repoMock.Verify(repo => repo.UpdateUser(It.Is <User>(u => u == user)), Times.Never);
}
public ApiResponse <bool> UpdatePassowrd(UpdatePasswordModel model)
{
if (model == null)
{
throw new Exception("The request body cant't be null.");
}
//旧密码
if (string.IsNullOrEmpty(model.Password))
{
throw new Exception("Invalid old password.");
}
//新密码
if (string.IsNullOrEmpty(model.NewPassword))
{
throw new Exception("Invalid new password.");
}
//加密密码
model.Password = Cryptology.Encrypt(model.Password);
model.NewPassword = Cryptology.Encrypt(model.NewPassword);
//更新密码
return(new ApiResponse <bool>
{
Result = this.UserService.UpdatePassowrd(this.Token, model)
});
}
public async Task <IActionResult> Put(UpdatePasswordModel model)
{
var command = model.Adapt <UpdatePasswordCommand>();
command.UserId = CurrentUserId;
return(Ok(await _mediator.Send(command)));
}
public IActionResult UpdatePassword(string UserEmail, string Token)
{
var updatePasswordModel = new UpdatePasswordModel();
updatePasswordModel.UserEmail = UserEmail;
updatePasswordModel.Token = Token;
return(View(updatePasswordModel));
}
public IActionResult UpdatePassword(string username)
{
UpdatePasswordModel model = new UpdatePasswordModel()
{
Username = username
};
return(View(model));
}
public IActionResult UpdatePassword(Guid userId)
{
var viewModel = new UpdatePasswordModel
{
UserId = userId
};
return(PartialView("_UpdatePassword", viewModel));
}
public void Try_ChangePassword_WithWrongCurrentPassword()
{
User account = controller.Create(model);
UpdatePasswordModel passwordModel = new UpdatePasswordModel
{
CurrentPassword = "******"
};
Assert.Throws <InvalidValueException> (() => controller.ChangePassword(account, passwordModel));
}
public ActionResult ChangePassword()
{
var user = User.Identity.GetUserName();
UpdatePasswordModel update = new UpdatePasswordModel()
{
Username = user
};
return(View(update));
}
public eErrors CheckIfPasswordsAreEquals(UpdatePasswordModel i_NewPassword)
{
eErrors error = eErrors.None;
if (!(i_NewPassword.NewPassword.Equals(i_NewPassword.NewConfirmPassword)))
{
error = eErrors.PasswordAreNotEqual;
}
return(error);
}
public bool UpdatePassword(UpdatePasswordModel obj)
{
try
{
return(_user.UpdatePassword(obj));
}
catch
{
throw;
}
}
public async Task <IActionResult> UpdatePasswordAsync(int id, UpdatePasswordModel model)
{
var result = await _userService.UpdatePasswordAsync(id, model);
if (result.IsFailure)
{
return(BadRequest(result.Errors));
}
return(Ok());
}
public IHttpActionResult UpdateUserPassword([FromBody] UpdatePasswordModel model)
{
var container = ContainerConfig.Configure();
using (var scope = container.BeginLifetimeScope())
{
var app = scope.Resolve <ILoginBusinessRules>();
string updateResult = app.UpdateUserPassword(model);
return(Json(new { Result = updateResult }));
}
}
public ActionResult ChangePassword(ChangePasswordModel model)
{
if (ModelState.IsValid)
{
UpdatePasswordModel upm = new UpdatePasswordModel();
upm.NewPassword = model.NewPassword;
upm.OldPassword = model.OldPassword;
upm.Username = User.Identity.Name;
if (accountServices.UpdatePassword(upm))
{
return RedirectToAction("ChangePasswordSuccess");
}
else
{
ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");
}
}
ViewData["PasswordLength"] = 6;
return View(model);
}
public bool UpdatePassword(UpdatePasswordModel changePasswordModel)
{
User user = db.Users.Where(x => x.Username == changePasswordModel.Username).FirstOrDefault();
if (user != null)
{
if (user.Password == changePasswordModel.OldPassword)
{
user.Password = changePasswordModel.NewPassword;
db.SaveChanges();
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
