public virtual ActionResult ChangePassword(ChangePasswordViewModel model) { if (ModelState.IsValid) { // ChangePassword will throw an exception rather // than return false in certain failure scenarios. bool changePasswordSucceeded; try { MembershipUser currentUser = Membership.GetUser(User.Identity.Name, true /* userIsOnline */); changePasswordSucceeded = currentUser.ChangePassword(model.OldPassword, model.NewPassword); } catch (Exception) { changePasswordSucceeded = false; } if (changePasswordSucceeded) { return RedirectToAction("ChangePasswordSuccess"); } else { ModelState.AddModelError("", "The current password is incorrect or the new password is invalid."); } } // If we got this far, something failed, redisplay form return RedirectToAction("ChangePassword"); }
public ActionResult ChangePassword(ChangePasswordViewModel model) { if (model == null) throw new ArgumentNullException("model"); if (ModelState.IsValid) { bool changePasswordSucceeded; try { changePasswordSucceeded = WebSecurity.ChangePassword(User.Identity.Name, model.OldPassword, model.NewPassword); } catch (Exception) { changePasswordSucceeded = false; } if (changePasswordSucceeded) { TempData["SuccessMessage"] = "Пароль успешно изменен"; } else { ModelState.AddModelError("", "Неправильный текущий пароль или недопустимый новый пароль."); } } return View(model); }
public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model) { if (!this.ModelState.IsValid) { return this.View(model); } var result = await this.UserManager .ChangePasswordAsync( User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (result.Succeeded) { var user = await this.UserManager.FindByIdAsync(User.Identity.GetUserId()); if (user != null) { await this.SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); } return this.RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess }); } this.AddErrors(result); return this.View(model); }
public ActionResult ChangePassword(ChangePasswordViewModel model) { if (this.ModelState.IsValid && this.authentication.ChangePassword(this.authentication.CurrentUserName, model.OldPassword, model.NewPassword)) { return this.RedirectToAction("ChangePassword", new { saveSuccessful = true }); } this.ModelState.AddModelError("", "The current password is incorrect or the new password is invalid."); return this.View(model); }
public void ChangePasswordAction_WithValidValuesReturnsRedirectToRoute() { // Arrange var controller = CreateAccountController(); var changePasswordView = new ChangePasswordViewModel { UserName = "******", OldPassword = "******", NewPassword = "******" }; // Act var result = controller.ChangePassword(changePasswordView); // Assert Assert.IsInstanceOf<RedirectToRouteResult>(result, "RedirectToRouteResult not returned."); }
public void ChangePasswordAction_ReturnsViewIfFails() { // Arrange var controller = CreateAccountController(); var changePasswordView = new ChangePasswordViewModel { UserName = "******", OldPassword = "******", NewPassword = "******" }; // Act var result = controller.ChangePassword(changePasswordView); var viewResult = (ViewResult)result; // Assert Assert.IsInstanceOf<ViewResult>(result, "ViewResult not returned."); Assert.AreSame(changePasswordView, viewResult.ViewData.Model, "User and Model are not the same"); Assert.AreEqual(false, viewResult.ViewData.ModelState.IsValid); }
public void ChangePasswordAction_WithValidValuesUpdatesPassword() { // Arrange var controller = CreateAccountController(); var user = new LoginViewModel { UserName = "******", Password = "******" }; var changePasswordView = new ChangePasswordViewModel { UserName = "******", OldPassword = "******", NewPassword = "******" }; // Act var result = controller.ChangePassword(changePasswordView); // Assert //Assert.IsInstanceOf<RedirectToRouteResult>(result, "Redirect to route not returned."); //Assert.AreEqual("Customers", redirectresult.RouteValues["controller"]); //Assert.AreEqual("Index", redirectresult.RouteValues["action"]); }
public void ChangePasswordAction_ReturnsViewIfInvalidModelState() { // Arrange var controller = CreateAccountController(); var changePasswordView = new ChangePasswordViewModel { UserName = "******", OldPassword = "******", NewPassword = "******" }; controller.ModelState.AddModelError("*", "Invalid model state."); // Act var result = controller.ChangePassword(changePasswordView); // Assert Assert.IsInstanceOf<ViewResult>(result, "ViewResult not returned."); var viewResult = (ViewResult)result; Assert.AreSame(changePasswordView, viewResult.ViewData.Model, "User and Model are not the same"); }
public async Task<IActionResult> Password(ChangePasswordViewModel viewModel) { if (!ModelState.IsValid) return RedirectToAction("Password"); return await _userService.SetNewPasswordAsync(UserId, viewModel.ActualPassword, viewModel.NewPassword) .Execute( onSuccess: () => { Notify(FlashNotificationType.Success, "Password has been changed."); return RedirectToAction("Index"); }, onFailure: ex => { Notify(FlashNotificationType.Error, ex.Message); return RedirectToAction("Password"); }); }
public ActionResult ChangePassword(ChangePasswordViewModel model) { model.UserName = User.Identity.Name; if (ModelState.IsValid) { if (MembershipService.ChangePassword(model.UserName, model.OldPassword, model.NewPassword)) { return RedirectToAction("ChangePasswordSuccess"); } ModelState.AddModelError("", "The current password is incorrect or the new password is invalid."); } // If we got this far, something failed, redisplay form ViewBag.PasswordLength = MembershipService.MinPasswordLength; return View(model); }
public JsonResult ChangePassword(ChangePasswordViewModel changePasswordView) { if (!ModelState.IsValid) { return Json(new { Success = false, Message = Resources.ValidationFailed }); } var command = new ChangePasswordCommand(UserInfo.Id, changePasswordView.CurrentPassword, changePasswordView.NewPassword); var result = ExecuteCommand(command); if (result) { TempData[ViewDataKeys.Message] = new SuccessMessage(Resources.PasswordChangeSuccess); return Json(new { Success = true }); } else { return Json(new { Success = false, Message = Resources.IncorrectCurrentPassword }); } }
public async Task<ActionResult> ChangePassword(ChangePasswordViewModel changePasswordViewModel) { if (!ModelState.IsValid) return View(changePasswordViewModel); var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId<int>(), changePasswordViewModel.CurrentPassword, changePasswordViewModel.NewPassword); if (result.Succeeded) { var user = await UserManager.FindByIdAsync(User.Identity.GetUserId<int>()); if (user != null) { AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie); await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); TempData["Message"] = ActionMessage.ChangePasswordSuccess; } return RedirectToAction("changepassword", "action"); } AddErrors(result); return View(changePasswordViewModel); }
public async Task <IActionResult> ChangePassword(ChangePasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await GetCurrentUserAsync(); if (user != null) { var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { await _signInManager.SignInAsync(user, isPersistent : false); _logger.LogInformation(3, "User changed their password successfully."); return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.ChangePasswordSuccess })); } AddErrors(result); return(View(model)); } return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error })); }
public async Task <ApiResponseDto> AdminChangePassword(ChangePasswordViewModel parameters) { return(await _accountApiClient.AdminChangePassword(parameters)); }
public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } var user = await GetCurrentUser(); if (user != null) { var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { await _signInManager.SignInAsync(user, isPersistent: false); return RedirectToAction(nameof(Microsoft.EntityFrameworkCore.Metadata.Internal.Index), new { Message = ManageMessageId.ChangePasswordSuccess }); } AddErrorsToModelState(result); return View(model); } return RedirectToAction(nameof(Microsoft.EntityFrameworkCore.Metadata.Internal.Index), new { Message = ManageMessageId.Error }); }
public ActionResult ChangePassword() { var vm = new ChangePasswordViewModel(); return(View(vm)); }
public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } var user = await GetCurrentUserAsync(); if (user != null) { var result = await UserManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent: false); return RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess }); } AddErrors(result); return View(model); } return RedirectToAction("Index", new { Message = ManageMessageId.Error }); }
private void OnSelectedMenuItem() { if (SelectedMenuItem == MenuResources.ChangePassword) { if (ChangePasswordViewModel == null) ChangePasswordViewModel = new ChangePasswordViewModel(this.Messenger, this.UserLogin) { ParentViewModel = this }; DetailSectionViewModel = ChangePasswordViewModel; return; } }
// GET: /Manage/ChangePassword public ActionResult ChangePassword() { ChangePasswordViewModel model = new ChangePasswordViewModel(); return this.View(model); }
public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model) { return(View()); }
public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } IdentityResult result = await _userManager.ChangePasswordAsync(User.Identity.GetUserId2<ObjectId>() , model.OldPassword, model.NewPassword); if (result.Succeeded) { var user = await _userManager.FindByIdAsync(User.Identity.GetUserId2<ObjectId>()); if (user != null) { await SignInAsync(user, isPersistent: false); } return RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess }); } AddErrors(result); return View(model); }
public async Task <IActionResult> ChangePassword(ChangePasswordViewModel model) { if (ModelState.IsValid) { UserIdent user = await _userManager.FindByIdAsync(model.Id); if (user != null) { var _passwordValidator = HttpContext.RequestServices.GetService(typeof(IPasswordValidator <UserIdent>)) as IPasswordValidator <UserIdent>; var _passwordHasher = HttpContext.RequestServices.GetService(typeof(IPasswordHasher <UserIdent>)) as IPasswordHasher <UserIdent>; IdentityResult result = await _passwordValidator.ValidateAsync(_userManager, user, model.NewPassword); if (result.Succeeded) { user.PasswordHash = _passwordHasher.HashPassword(user, model.NewPassword); await _userManager.UpdateAsync(user); return(RedirectToAction("Index")); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } else { ModelState.AddModelError(string.Empty, "Пользователь ненайден"); } } return(View(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"); // } // else // { // foreach (var error in result.Errors) // { // ModelState.AddModelError(string.Empty, error.Description); // } // } // } // else // { // ModelState.AddModelError(string.Empty, "Пользователь не найден"); // } //} //return View(model); }
public ChangePassword() { InitializeComponent(); this.BindingContext = ViewModel = new ChangePasswordViewModel(); }
public ActionResult EditUserPasswordPost(ChangePasswordViewModel model) { if (!Services.Authorizer.Authorize(Permissions.ChangePassword, T("Not authorized to manage users"))) return new HttpUnauthorizedResult(); var user = Services.ContentManager.Get<UserPart>(model.UserId); if (!this.ModelState.IsValid) { var viewModel = new ChangePasswordViewModel() { UserPart = user, UserId = user.Id }; return View(viewModel); } _membershipService.SetPassword(user, model.Password); notifier.Information(T("User password for " + user.UserName + " changed!")); return RedirectToAction("Index"); }
public bool ChangePassword(ChangePasswordViewModel model, string id) { var result = _userManager.ChangePassword(id, model.OldPassword, model.NewPassword); return(result.Succeeded); }
public virtual ActionResult ChangePassword() { var viewModel = new ChangePasswordViewModel(); return View(viewModel); }
public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model) { if (!this.ModelState.IsValid) { return this.View(model); } var result = await this.UserManager.ChangePasswordAsync(this.User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (result.Succeeded) { var user = await this.UserManager.FindByIdAsync(this.User.Identity.GetUserId()); if (user != null) { await this.SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); } this.AddToastMessage("Congratulations", "Your password has been changed.", ToastType.Success); return this.RedirectToAction<HomeController>(c => c.Index()); } this.AddErrors(result); return this.View(model); }
public IActionResult ChangePassword() { ChangePasswordViewModel view = new ChangePasswordViewModel(); return(View("ChangePassword", view)); }
public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model) { string strError = string.Empty; try { if (ModelState.IsValid) { await ParseUser.RequestPasswordResetAsync(model.Email); model.Message = Strings.GetLocalizedString(Strings.ChangePasswordSuccessMessage); model.IsSuccess = true; model.CaptchaOK = true; } else { model.CaptchaOK = false; } } catch (Exception ex) { strError = ex.ToString(); model.IsSuccess = false; } if (!string.IsNullOrEmpty(strError)) { await ParseLogger.Log("Change Password", strError); model.Message = MyMentorResources.validationChangePasswordError; return View(model); } return View(model); }
public ActionResult ChangePassword(string username) { var model = new ChangePasswordViewModel(); return(View("ChangePassword", model)); }
public ChangePasswordPopup() { InitializeComponent(); BindingContext = new ChangePasswordViewModel(); }
public ActionResult EditUserPassword(int id) { if (!Services.Authorizer.Authorize(Permissions.ChangePassword, T("Not authorized to manage users"))) return new HttpUnauthorizedResult(); var user = Services.ContentManager.Get<UserPart>(id); var viewModel = new ChangePasswordViewModel() { UserPart = user, UserId = user.Id }; return View(viewModel); }
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordViewModel model) { IActionResult _result = new ObjectResult(false); GenericResult _authenticationResult = null; try { ApplicationUser appUser = null; if (!String.IsNullOrEmpty(model.Id)) { appUser = await _userManager.FindByIdAsync(model.Id); } else if (!String.IsNullOrEmpty(model.UserName)) { appUser = await _userManager.FindByNameAsync(model.UserName); } //else //{ // appUser = await _userManager.FindByIdAsync(model.Id); //} if (appUser != null) { var result = await _userManager.ChangePasswordAsync(appUser, model.OldPassword, model.NewPassword); if (result.Succeeded) { _authenticationResult = new GenericResult() { Succeeded = true, Message = "Đổi mật khẩu thành công", }; } else { _authenticationResult = new GenericResult() { Succeeded = false, Message = "Đổi mật khẩu thất bại", }; } } else { _authenticationResult = new GenericResult() { Succeeded = false, Message = "Không tìm thấy ID", }; } } catch (Exception ex) { _authenticationResult = new GenericResult() { Succeeded = false, Message = ex.Message }; _loggingRepository.Add(new Error() { Message = ex.Message, StackTrace = ex.StackTrace, DateCreated = DateTime.Now }); _loggingRepository.Commit(); } _result = new ObjectResult(_authenticationResult); return(_result); }
public IActionResult ChangePassword() { var model = new ChangePasswordViewModel(); return(View(model)); }
public ActionResult ChangePassword(ChangePasswordViewModel model) { if (this.ModelState.IsValid) { var request = new ChangePasswordRequest { UserName = "******", OldPassword = model.OldPassword, NewPassword = model.NewPassword }; var response = this.accountService.ChangePassword(request); if (response.Status == StatusCode.OK) { this.TempData["SuccessMessage"] = "You have successfully changed your password."; return this.RedirectToAction("Index"); } else { this.ViewBag.DisplaySummary = "yes"; this.ModelState.AddModelError(string.Empty, "Your old password has not been recognised. Please try again."); } } return this.View(); }
public virtual ActionResult ChangePassword() { var viewModel = new ChangePasswordViewModel(); return(View(viewModel)); }
public async Task <IActionResult> UserChangePassword(ChangePasswordViewModel user) { var data = await _userService.UserChangePasswordAsync(user); return(Ok(data)); }
protected override void OnNavigatedTo(NavigationEventArgs e) { User = new EditAccountViewModel(); Passwords = new ChangePasswordViewModel(); }
public IActionResult ChangePassword() { var user = new ChangePasswordViewModel(); return(View("ChangePassword", user)); }
public IActionResult ChangePassword() { var passwordViewModel = new ChangePasswordViewModel(); return(this.View(passwordViewModel)); }
//[ValidateAntiForgeryToken] public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model) { if (ModelState.IsValid) { var userID = GetCurrentUserID(); var result = await this.UserManager.ChangePasswordAsync(userID, model.OldPassword, model.NewPassword); if (result.Succeeded) { var user = await GetCurrentUserAsync(); user.ChangedPassword = true; var updateUserResult = await this.UserManager.UpdateAsync(user); if (result.Succeeded) { return Json("OK", JsonRequestBehavior.AllowGet); } else { return JsonMessage.BadRequestJsonResult(updateUserResult.Errors); } } else { return JsonMessage.BadRequestJsonResult(result.Errors); } } return JsonMessage.BadRequestJsonResult(ModelState.Values.SelectMany(x => x.Errors)); }
public ActionResult ChangePassword(ChangePasswordViewModel model) { Func<ChangePasswordViewModel, ChangePasswordViewModel> setCommonValues = delegate(ChangePasswordViewModel modelTmp) { modelTmp.BaseViewModelInfo.Title = $customNamespace$.Resources.Account.AccountResources.ChangePassword; modelTmp.MinPasswordLength = this.FormsMembershipService.Settings().Data.MinRequiredPasswordLength; return modelTmp; }; if (this.RequestType() == HttpVerbs.Get) { model = setCommonValues(new ChangePasswordViewModel()); return View(model); } else { model = setCommonValues(model); if (ModelState.IsValid) { FormsIdentity identity = this.FormsAuthenticationService.GetFormsIdentity(); DataResultBoolean result = this.FormsMembershipService.ChangePassword(identity.Name, model.OldPassword, model.NewPassword, model.ConfirmPassword); if (result.IsValid) { model.Result = result; } else { ModelState.AddModelError("InvalidPassword", result.Message); } } return View(model); } }
public ActionResult ChangePassword() { ChangePasswordViewModel CPVM = new ChangePasswordViewModel(); return(View(CPVM)); }
public ActionResult ChangePassword(ChangePasswordViewModel model) { if (!ModelState.IsValid) return View(model); using (var Context = new ProjectDBEntities()) { var oldPassword = Hashing.CreateHash(model.OldPassword); var user = Context.SiteUsers .Where(x => x.UserName == User.Identity.Name && x.UserPass == oldPassword) .FirstOrDefault<SiteUser>(); if (user == null) { ViewBag.Message = "Old password doesn't match.."; return View(model); } user.UserPass = Hashing.CreateHash(model.NewPassword); Context.SaveChanges(); ViewBag.Message = "Password Changed Successfully.."; return View(new ChangePasswordViewModel()); } }
public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (result.Succeeded) { var user = await UserManager.FindByIdAsync(User.Identity.GetUserId()); if (user != null) { await SignInAsync(user, isPersistent: false); } //return RedirectToAction("Index", new { Message = IdentitySample.Controllers.ManageController.ManageMessageId.ChangePasswordSuccess }); //return RedirectToAction("Index", "Dashboard"); ViewBag.MessageVM = new MessageViewModel {Message = "Password has been updated.", IsUpdated = true}; return View(); } else { ViewBag.MessageVM = new MessageViewModel { Message = "Incorrect old Password", IsError = true }; } AddErrors(result); return View(model); }
public ActionResult ChangePassword(ChangePasswordViewModel model) { ResponseModel response = new ResponseModel(); UserInfo user = _userInfoService.GetById(model.Id); user.Password = model.Password.ToMd5String(); _userInfoService.Update(user); _unitOfWork.Commit(); response.Msg = "重置密码成功!"; response.Success = true; response.RedirectUrl = string.Empty; return Json(response, JsonRequestBehavior.AllowGet); }
public ActionResult ChangePassword(ChangePasswordViewModel changePasswordViewModel) { if(!this.ValidateAndForwardMessages(changePasswordViewModel)) { return RedirectToAction("settings", "user"); } using(var unitOfWork = this.UnitOfWorkFactory.NewUnitOfWork()) { try { if(!this.UserLoginService.VerifyUserPassword(this.ActiveUser.UserId, changePasswordViewModel.CurrentPassword)) { return Json(new { Success = false, Message = "The current password you provided is not correct" }); } this.UserLoginService.SetUserPassword(this.ActiveUser.UserId, changePasswordViewModel.NewPassword); unitOfWork.Commit(); } catch (Exception ex) { this.LogHandledException(ex); unitOfWork.Rollback(); return Json(new { Success = false, Message = GenericMessages.ErrorMessage }); } } return Json(new { Success = true, Message = "Your password has been changed" }); }
public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (result.Succeeded) { // Fouche - Update tblCustomer met nuwe PIN. string Email = User.Identity.GetUserName(); tblCustomer tblCustomers = new tblCustomer(); tblCustomer tblCustomerEx = db.tblCustomers.FirstOrDefault(i => i.CustomerID == Email); // Kry net die ID op tblCustomer if (tblCustomerEx == null) // voeg by { //tblCustomers.CustomerID = model.Email; // Kan dalk later verander. //tblCustomers.CustomerID = User.Identity. //tblCustomers.CompanyName = model.CompanyName; //tblCustomers.CompanyID = model.CustomerID; //tblCustomers.eMail = model.Email; //tblCustomers.Phone = model.PhoneNumber; //tblCustomers.ContactPerson = model.ContactPerson; //tblCustomers.CellPhone = model.ContactCellPhone; //tblCustomers.Active = true; //tblCustomers.VATRegistered = false; //tblCustomers.PIN = model.PIN; //companyName = model.CompanyName; //Email = model.Email; //db.tblCustomers.Add(tblCustomers); //db.SaveChanges(); } else { // tblCustomer tblCustomersF = db.tblCustomers.FirstOrDefault(i => i.CustomerID == model.Email); //db.Entry(tblCustomersF).State = EntityState.Modified; //tblCustomersF.CompanyName = model.CompanyName; //tblCustomersF.CompanyID = model.CustomerID; //tblCustomersF.eMail = model.Email; //tblCustomersF.Phone = model.PhoneNumber; //tblCustomersF.ContactPerson = model.ContactPerson; //tblCustomersF.CellPhone = model.ContactCellPhone; // tblCustomerEx.Active = true; // tblCustomerEx.VATRegistered = false; tblCustomerEx.PIN = model.PIN; //companyName = model.CompanyName; //Email = model.Email; db.CustomersPIN(tblCustomerEx.ID, model.PIN); // db.SaveChanges(); } // Fouche - end var user = await UserManager.FindByIdAsync(User.Identity.GetUserId()); if (user != null) { await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false); } return(RedirectToAction("Index", "Home", new { Message = ManageMessageId.ChangePasswordSuccess })); } AddErrors(result); return(View(model)); }
public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } var user = await GetCurrentUserAsync(); if (user != null) { var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { await _signInManager.SignInAsync(user, isPersistent: false); _logger.LogInformation(3, "User changed their password successfully."); return RedirectToAction(nameof(Index), new { Message = ManageMessageId.ChangePasswordSuccess }); } AddErrors(result); return View(model); } return RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error }); }
public ActionResult ChangePassword() { ChangePasswordViewModel vModel = new ChangePasswordViewModel(); return View(vModel); }