public async Task PostChangePassword_ReturnViewResult() { var user = new UserChangePasswordViewModel(); var result = await _userController.ChangePassword(user); Assert.IsType <PartialViewResult>(result); }
public ActionResult EditPassword(string uuid) { var user = _userService.FindBy(e => e.Uuid == uuid).FirstOrDefault(); if (user == null) { string message = Resources.ErrorMessages.UserNotAvailable; if (Request.IsAjaxRequest()) { return(JsonStatusGone(message)); } else { AddViewMessage(TypeMessageView.ERROR, message); return(RedirectToAction("Index")); } } UserChangePasswordViewModel model = new UserChangePasswordViewModel { Uuid = uuid, Password = null, ConfirmPassword = null }; if (Request.IsAjaxRequest()) { return(PartialView(model)); } return(View(model)); }
public ActionResult ChangePassword(UserChangePasswordViewModel objEntity) { int result = 0; UserRepository objUserRepository = new UserRepository(); if (ModelState.IsValid) { objEntity.NewPassword = objEntity.NewPassword.Trim(); objEntity.OldPassword = objEntity.OldPassword.Trim(); objEntity.UserEmail = SessionWrapper.UserAccount.UserEmail; result = ValidateUserChangePassword(objEntity); if (result == ResultFlags.Success.GetHashCode()) { this.Flash("Success", "Password updated successfully"); AccountRepository.Logout(); return(RedirectToAction("Login", "User")); } else if (result == ResultFlags.Failure.GetHashCode()) { this.Flash("Error", "Password failed to update"); } else if (result == ResultFlags.OldPasswordMismatch.GetHashCode()) { this.Flash("Warning", "Old password and new password cannot be same"); } } return(View(objEntity)); }
public async Task ChangePasswordAsync_UserNUll_ReturnFalse() { var user = new UserChangePasswordViewModel(); var result = await _userService.ChangePasswordAsync(user); Assert.False(result); }
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model) { var user = await _userManager.FindByNameAsync(HttpContext.User.Identity.Name); var hasPassword = await _userManager.HasPasswordAsync(user); if (!hasPassword) { ModelState.AddModelError("", "Пж, при сторонней авторизации пороль не нужен"); return(RedirectToAction("Profile", "Account")); } if (!ModelState.IsValid) { ModelState.AddModelError("", "Неверные вводы"); return(View()); } var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { return(RedirectToAction("ChangePasswordConfirmation", "Account")); } ModelState.AddModelError("", "Опрокидень смены пароля"); return(View()); }
public async Task <IActionResult> ChangePasswordCurUser(UserChangePasswordViewModel model) { if (ModelState.IsValid) { User user = await _userManager.FindByIdAsync(model.Id); if (user != null) { IdentityResult result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { return(RedirectToAction("Index", "Home")); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } else { ModelState.AddModelError(string.Empty, "User not found"); } } return(View(model)); }
public virtual async Task <ActionResult> ChangePassword(UserChangePasswordViewModel viewModel) { // Check if (viewModel == null) { return(View(MVC.Error.Views.BadRequest)); } // Validation if (!ModelState.IsValid) { return(View(MVC.User.Views.ChangePassword, viewModel)); } // Result var result = await _userService.ChangePasswordAsync(Guid.Parse(User.Identity.GetUserId()), viewModel.OldPassword, viewModel.NewPassword); if (result.Succeeded) { var user = await _userService.FindByIdAsync(Guid.Parse(User.Identity.GetUserId())); await _signInManagerService.SignInAsync(user, false, false); return(RedirectToAction(MVC.Account.SignOut())); } return(View(MVC.User.Views.ChangePassword, viewModel)); }
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model) { if (ModelState.IsValid) { var user = await _userManager.FindByIdAsync(model.Id); if (user == null) { return(NotFound()); } await _userManager.RemovePasswordAsync(user); await _userManager.AddPasswordAsync(user, model.Password); var result = await _userManager.UpdateAsync(user); if (result.Succeeded) { return(RedirectToAction("Index")); } else { AddErrors(result); } } return(View(model)); }
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model) { if (!HasPermission("CHANGE_USERS_PASSWORDS")) { return(Unauthorized()); } if (ModelState.IsValid) { var user = await _userManager.Users.FirstOrDefaultAsync(u => u.Id == model.Id); if (user == null) { return(NotFound()); } await _userManager.RemovePasswordAsync(user); await _userManager.AddPasswordAsync(user, model.Password); var result = await _userManager.UpdateAsync(user); if (result.Succeeded) { return(RedirectToAction("Index")); } else { AddErrors(result); } } return(View(model)); }
public async Task <IActionResult> EditPassword(UserChangePasswordViewModel vm) { if (vm.newPassword != vm.conPassword) { TempData.AddResult(SweetAlertExtenstion.Error("NewPassword and Confirm not equal")); return(RedirectToAction("Index")); } var user = await _userRepository.GetByIdAsync(this.UserId); //if (user.PasswordHash == vm.oldPassword) //{ var newVm = new AdminSetPasswordViewModel { UserId = this.UserId, Password = vm.Password }; var sweetMessage = await _userRepository.AdminChangePassword(newVm); TempData.AddResult(sweetMessage); //} //else //{ // TempData.AddResult(SweetAlertExtenstion.Error("Old Password is incorect")); //} return(RedirectToAction("Profile")); }
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model) { if (ModelState.IsValid) { var user = await repository.UserManager.FindByIdAsync(model.Id); if (user != null) { if (!await repository.UserManager.CheckPasswordAsync(user, model.ConfirmPassword)) { ModelState.AddModelError(string.Empty, "Password is not correct"); return(View(model)); } var result = await repository.UserManager.ResetPasswordAsync( user, await repository.UserManager.GeneratePasswordResetTokenAsync(user), model.NewPassword); if (result.Succeeded) { ModelState.AddModelError(string.Empty, "Your password has been changed"); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } } return(View(model)); }
/// <summary> /// Executa a troca de senha do usuário autenticado. /// </summary> /// <param name="userChange"></param> /// <returns></returns> public async Task <UserChangePasswordOutViewModel> ChangePassword(UserChangePasswordViewModel userChange) { if (userChange.CurrentPassword == userChange.NewPassword) { return new UserChangePasswordOutViewModel() { Code = 204, Description = "New password should be different than current password." } } ; var mail = _authenticatedUser.GetEmail(); var user = await _userManager.FindByEmailAsync(mail); var result = await _userManager.ChangePasswordAsync(user, userChange.CurrentPassword, userChange.NewPassword); if (!result.Succeeded) { return new UserChangePasswordOutViewModel() { Code = 204, Description = "Could not change password." } } ; return(new UserChangePasswordOutViewModel() { Code = 200, Description = "New password registered." }); }
public async Task <ActionResult> ChangePassword(UserChangePasswordViewModel model) { if (!ModelState.IsValid) { Response.StatusCode = (int)HttpStatusCode.BadRequest; return(PartialView(model)); } if (model.NewPassword != model.NewPasswordCopy) { ModelState.AddModelError("", "The new password and confirmation password does not match."); Response.StatusCode = (int)HttpStatusCode.BadRequest; return(PartialView(model)); } AppUser user = GetCurrentUser(); bool correctPass = await _userManager.CheckPasswordAsync(user, model.OldPassword); if (!correctPass) { ModelState.AddModelError("", "Please enter valid current password."); Response.StatusCode = (int)HttpStatusCode.BadRequest; return(PartialView(model)); } IdentityResult validPass = await _userManager.PasswordValidator.ValidateAsync(model.NewPassword); if (validPass.Succeeded) { user.PasswordHash = _userManager.PasswordHasher.HashPassword(model.NewPassword); } else { AddErrorsFromResult(validPass); } if (validPass == null || (model.NewPassword != string.Empty && validPass.Succeeded)) { IdentityResult result = await _userManager.UpdateAsync(user); if (result.Succeeded) { _mailingRepository.PasswordChangedMail(user.Email); NotifyManager.Set("notification-success", "Success!", "Your password has been changed!"); return(Json(new { url = Url.Action("Index") })); } else { AddErrorsFromResult(result); } } else { ModelState.AddModelError("", "User Not Found"); } Response.StatusCode = (int)HttpStatusCode.BadRequest; return(PartialView(model)); }
public async Task <ActionResult> ChangePassword(UserChangePasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } if (model.NewPassword != model.NewPasswordCopy) { ModelState.AddModelError("", ErrorMessage.PasswordsDontMatch); return(View(model)); } AppUser user = GetCurrentUser(); if (user != null) { bool correctPass = await _userManager.CheckPasswordAsync(user, model.OldPassword); if (!correctPass) { ModelState.AddModelError("", ErrorMessage.PasswordNotValid); return(View(model)); } IdentityResult validPass = await _userManager.PasswordValidator.ValidateAsync(model.NewPassword); if (validPass.Succeeded) { user.PasswordHash = _userManager.PasswordHasher.HashPassword(model.NewPassword); IdentityResult result = await _userManager.UpdateAsync(user); if (result.Succeeded) { _mailingRepository.PasswordChangedMail(user.Email); return(RedirectToAction("Index")); } else { AddErrorsFromResult(result); } } else { AddErrorsFromResult(validPass); return(View(model)); } } else { ModelState.AddModelError("", ErrorMessage.NullUser); } return(View(model)); }
public async Task ChangePasswordAsync_ReturnTrue() { var user = new UserChangePasswordViewModel { Id = 1, NewPassword = "******", }; var result = await _userService.ChangePasswordAsync(user); Assert.True(result); }
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel change_password) { var result = await userService.ChangePassword(change_password.OldPassword, change_password.NewPassword, ModelState, User); if (!result) { return(View()); } return(RedirectToAction("Index", "User")); }
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model) { if (ModelState.IsValid) { await _accountService.ChangePasswordAsync(model.Password); return(Json(new { success = true, responseText = "Your message successfuly sent!" })); } return(PartialView("_ChangePassword", model)); }
// [Authorize("Admin")] public async Task <IActionResult> ChangePassword([FromBody] UserChangePasswordViewModel userChangePasswordViewModel) { var user = await _userManager.Users.Where(e => e.Id == userChangePasswordViewModel.Id).FirstOrDefaultAsync(); var result = await _userManager.ChangePasswordAsync(user, userChangePasswordViewModel.CurrentPassword, userChangePasswordViewModel.NewPassword); if (!result.Succeeded) { return(StatusCode(400, "Error during change password!")); } return(new OkObjectResult(result.Succeeded)); }
public async Task PostChangePassword_ReturnRedirectToActionResult() { var user = new UserChangePasswordViewModel() { Id = 1, Email = "*****@*****.**", NewPassword = "******" }; var result = await _userController.ChangePassword(user); Assert.IsType <PartialViewResult>(result); }
public IActionResult ChangePassword(UserChangePasswordViewModel ucpvm) { if (ModelState.IsValid) { bool success = _repository.ChangePassword(ucpvm.CurrentPassword, ucpvm.NewPassword); if (success == true) { return(RedirectToAction("Index", "Home")); } ModelState.AddModelError("", "Unable To Change Password"); return(View(ucpvm)); } return(View(ucpvm)); //[HttpGet] //public IActionResult Edit(int id) //{ // User u = _repository.GetUserById(id); // return View(u); //} //[HttpPost] //public IActionResult Edit(User u) //{ // if (ModelState.IsValid) // { // _repository.Update(u); // return RedirectToAction("Details", new { id = u.UserId }); // } // return View(u); //} // Delete ----------------------------------------------------------------------------------- //[HttpGet] //public IActionResult Delete(int id) //{ // User u = _repository.GetUserById(id); // if (u != null) // { // return View(u); // } // return RedirectToAction("Index"); //} //[HttpPost] //public IActionResult Delete(User u) //{ // _repository.Delete(u.UserId); // return RedirectToAction("Index"); //} }
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model) { if (!await _service.UserService.ValidateKeyOfChangePassword(model.Key)) { return(BadRequest("Key invalida")); } var result = await _service.UserService.ChangePasswordAsync(model); if (!result) { return(NoContent()); } return(Ok(result)); }
public IActionResult ChangePassword(UserChangePasswordViewModel ucpvm) { if (ModelState.IsValid) { bool success = _repository.ChangePassword(ucpvm.CurrentPassword, ucpvm.NewPassword); if (success == true) { return(RedirectToAction("Index", "Home")); } ModelState.AddModelError("", "Unable To Change Password"); return(View(ucpvm)); } return(View(ucpvm)); }
public async Task <IActionResult> PostForChangePassowrd([FromBody] UserChangePasswordViewModel vm) { var user = await userManager.FindByNameAsync("dnetrainadmin"); var changePassword = await userManager.ChangePasswordAsync(user, vm.OldPassword, vm.Password); if (!changePassword.Succeeded) { return(BadRequest("原密碼錯誤")); } else { return(Ok("密碼更改成功")); } }
public async Task <bool> ChangePasswordAsync(UserChangePasswordViewModel user) { var userResult = await _userManager.FindByNameAsync(user.UserName); if (userResult == null) { return(false); } var newPassword = _userManager.PasswordHasher.HashPassword(userResult, user.Password); userResult.PasswordHash = newPassword; var result = await _userManager.UpdateAsync(userResult); return(result.Succeeded); }
public async Task <IActionResult> ChangePassword() { var user = await repository.UserManager.FindByNameAsync(User.Identity.Name); if (user is null) { return(NotFound($"User with username '{User.Identity.Name}' was not found")); } UserChangePasswordViewModel model = new UserChangePasswordViewModel { Id = user.Id, Username = user.UserName }; return(View(model)); }
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel changePasswordModel) { if (ModelState.IsValid) { var user = await _userService.ChangePasswordAsync(changePasswordModel); if (user) { TempData["SuccessMessage"] = _localizer.GetLocalizedString("msg_ChangePasswordSuccess").ToString(); return(PartialView("_ChangePasswordPartial", changePasswordModel)); } TempData["ErrorMessage"] = _localizer.GetLocalizedString("err_ChangePassword").ToString(); return(PartialView("_ChangePasswordPartial", changePasswordModel)); } return(PartialView("_ChangePasswordPartial", changePasswordModel)); }
public async Task <IActionResult> ChangePassword(string id) { User user = await userManager.FindByIdAsync(id); if (user != null) { UserChangePasswordViewModel model = new UserChangePasswordViewModel { Id = user.Id, Email = user.Email, }; return(View(model)); } return(NotFound()); }
public ActionResult ChangePassword(UserChangePasswordViewModel vm) { if (Request.HttpMethod != "POST") { return(View(vm)); } if (!ModelState.IsValid) { return(View(vm)); } Svc.User.CheckPassword(User.Identity.GetAccount(), vm.OldPassword); Svc.User.SetPassword(User.Identity.GetUserId(), vm.Password); TempData["StatusSuccess"] = "儲存成功!!"; return(View(vm)); }
public ActionResult EditPassword(UserChangePasswordViewModel model) { var user = _userService.FindBy(e => e.Uuid == model.Uuid).FirstOrDefault(); if (user == null) { string message = Resources.ErrorMessages.UserNotAvailable; if (Request.IsAjaxRequest()) { return(JsonStatusGone(message)); } else { AddViewMessage(TypeMessageView.ERROR, message); return(RedirectToAction("Index")); } } if (ModelState.IsValid) { user.Password = SecurityUtil.EncryptPassword(model.Password); DateTime todayDate = DateUtil.GetDateTimeNow(); DateTime passwordExpiration = todayDate.AddDays(-1); user.PasswordExpiration = passwordExpiration; _userService.Update(user); string successMessage = Resources.Messages.UserPasswordUpdated; if (Request.IsAjaxRequest()) { return(Json(new { Message = successMessage })); } AddViewMessage(TypeMessageView.SUCCESS, successMessage); return(RedirectToAction("Index")); } if (Request.IsAjaxRequest()) { Response.StatusCode = 422; return(Json(new { issue = model, errors = ModelState.Keys.Where(k => ModelState[k].Errors.Count > 0) .Select(k => new { propertyName = k, errorMessage = ModelState[k].Errors[0].ErrorMessage }) })); } return(View(model)); }
/// <inheritdoc /> /// <summary> /// ChangePasswordAsync /// </summary> /// <param name="changePasswordViewModel">UserChangePasswordViewModel</param> /// <returns>Could be Changed?</returns> public async Task <bool> ChangePasswordAsync(UserChangePasswordViewModel changePasswordViewModel) { try { var user = await _context.Users.FindAsync(changePasswordViewModel.Id); user.Password = SecurePasswordHasher.Hash(changePasswordViewModel.NewPassword); _context.Users.Update(user); await _context.SaveChangesAsync(); return(true); } catch (Exception e) { Log.Error(e.Message); return(false); } }