private ActionResult TryResetPassword(ResetPasswordViewModel model) { try { var tokenValidation = this.Service.ValidateResetToken(model.ResetToken); if (tokenValidation.Type == ResetToken.ResetType.Both) { if (!this.Service.IsPasswordStrengthPassed(model.Password)) throw new WeakPasswordException(); SavePasswordToSession(model.Password); return RedirectToAction("ResetSecurePhrase", new { resetToken = model.ResetToken }); } this.Service.FinishResetPassword(model.ResetToken, model.Password); return RedirectToAction("ResetPasswordConfirmation"); } catch (InvalidResetTokenException) { AddModelStateError(GlobalStrings.ResetTokenIsInvalid); } catch (WeakPasswordException) { AddModelStateError(GlobalStrings.WeakPassword); } catch (Exception) { AddModelStateError(GlobalStrings.SomethingWentWrong); } return View(model); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return RedirectToAction("ResetPasswordConfirmation", "User"); } if (model.Password != model.ConfirmPassword) { ModelState.AddModelError("", "Password and Confirm Password Mismatch"); return View(); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code.Replace(" ", "+"), model.Password); if (result.Succeeded) { return RedirectToAction("ResetPasswordConfirmation", "User"); } AddErrors(result); return View(); }
public ActionResult ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) return Json(new ServiceOperationResult(false) {Message = Main.InvalidForm}); return Json(PiServices.UserService.ChangePassword(model)); }
public ActionResult ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) return TryResetPassword(model); // If we got this far, something failed, redisplay form return View(model); }
private ActionResult ResetPasswordView(string resetToken) { var model = new ResetPasswordViewModel() { ResetToken = resetToken, }; return View(model); }
public ServiceOperationResult ChangePassword(ResetPasswordViewModel model) { User user = UserRepository.GetUser(UserName); if(user.Password != HashHelpers.GetSHA256Hash(model.OldPassword, user.Salt.ToString())) { return new ServiceOperationResult(false) {Message = Main.OldPasswordInvalid}; } return Mapper.Map<DataResult, ServiceOperationResult>(UserRepository.ChangePassword(user, model.NewPassword)); }
public ActionResult ResetPassword(string userName) { var model = new ResetPasswordViewModel() { Username = userName, NewPassword = "******" // generate }; // reset the password return View(model); }
public ActionResult ResetPassword(ResetPasswordViewModel model) { if(ModelState.IsValid) { membershipService.ResetPassword(model.Username); membershipService.Commit(); SuccessMessage(FormMessages.AccountResetPassword); return RedirectToAction("Index", "Home"); } return View(model); }
public ActionResult ResetPassword(string code) { if (code == null) { return View("Error"); } ResetPasswordViewModel md = new ResetPasswordViewModel() { Code = code }; return View(md); }
public ActionResult Index(ResetPasswordViewModel rp) { //get the email from the URL string email = Request.QueryString["user_email"]; //collect the data from the form if (ModelState.IsValid) { if (!SecurityHelper.StripHTML(rp.Password).Equals(SecurityHelper.StripHTML(rp.ConfPassword))) //the passwords have to match { ViewBag.Message = "The two passwords have to match."; return View("ResetPassword"); } else //made it through both checks { var collectUser = ( from usr in db.Users where usr.email.Equals(SecurityHelper.StripHTML(email)) select usr ).First(); collectUser.password = AuthenticationHelper.ENCRYPT_ME(SecurityHelper.StripHTML(rp.Password)); try { db.SaveChanges(); return RedirectToAction("Index", "Login"); } catch (Exception ex) { ViewBag.Message = "Something weird happened. Try again."; return View("ResetPassword"); } } } else { ViewBag.Message = "You have to fill in both fields."; return View("ResetPassword"); } }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Nie ujawniaj informacji o tym, że użytkownik nie istnieje return(RedirectToAction("ResetPasswordConfirmation", "Account")); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirmation", "Account")); } AddErrors(result); return(View()); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return(RedirectToAction("ResetPasswordConfirmation", "Account")); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirmation", "Account")); } AddErrors(result); return(View()); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByEmailAsync(model.Email); if (user == null) { ModelState.AddModelError("Email", "No user found"); return(View(model)); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirmation", "Account")); } AddErrors(result); return(View()); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Ne révélez pas que l'utilisateur n'existe pas return(RedirectToAction("ResetPasswordConfirmation", "Account")); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirmation", "Account")); } AddErrors(result); return(View()); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Не показывать, что пользователь не существует return(RedirectToAction("ResetPasswordConfirmation", "Account")); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirmation", "Account")); } AddErrors(result); return(View()); }
public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { // Find the user by email var user = await userManager.FindByEmailAsync(model.Email); if (user != null) { // reset the user password var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password); if (result.Succeeded) { // Upon successful password reset and if the account is lockedout, set // the account lockout end date to current UTC date time, so the user // can login with the new password if (await userManager.IsLockedOutAsync(user)) { await userManager.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow); } return View("ResetPasswordConfirmation"); } // Display validation errors. For example, password reset token already // used to change the password or password complexity rules not met foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } return View(model); } // To avoid account enumeration and brute force attacks, don't // reveal that the user does not exist return View("ResetPasswordConfirmation"); } // Display validation errors if model state is not valid return View(model); }
public ActionResult ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); // chyba => zpět na formulář } else { // kontrola formátu hesla - obsahuje číslici? Regex rv = new Regex("[0-9]"); // test, zda heslo obsahuje nějakou číslici if (!rv.IsMatch(model.Password)) { // přidání českého chybového hlášení k položce formuláře (http://www.tutorialsteacher.com/mvc/htmlhelper-validationsummary): ModelState.AddModelError("Password", "Heslo musí obsahovat alespoň jednu číslici."); return(View(model)); // chyba => zpět na formulář } } ApplicationUser user = UserManager.FindByName(model.UserName); if (user == null) { TempData.Add("error", "Chyba: neplatné uživatelské jméno. Najděte řádek uživatele a klikněte na odkaz vpravo."); return(RedirectToAction("Users", "Account")); } if (!UserManager.IsInRole(user.Id, "user")) // nejedná se o uživatele v roli "user"! { TempData.Add("error", "Heslo lze nastavit pouze uživateli v roli 'user', nikoli jinému administrátorovi."); return(RedirectToAction("Users", "Account")); } if (user.PasswordHash != null) // musíme odstranit staré heslo { UserManager.RemovePassword(user.Id); } UserManager.AddPassword(user.Id, model.Password); // nastavení nového hesla TempData.Add("Message", "Heslo pro uživatele '" + model.UserName + "' bylo úspěšně nastaveno."); return(RedirectToAction("Users", "Account")); }
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var user = await _userManager.FindByIdAsync(model.UserId); if (user is null) { ViewBag.ErrorTitle = "Reset Password"; ViewBag.ErrorMessage = $"The User Id: {model.UserId} or token {model.Token} is invalid. Please contact with support."; return(View(error)); } model.Token = model.Token.Replace(" ", "+"); var result = await _userManager.ResetPasswordAsync(user, model.Token, model.Password); if (result.Succeeded) { //_signInManager.PasswordSignInAsync(user, user) ViewBag.ErrorTitle = "Reset Password"; ViewBag.ErrorMessage = "Your password was successfully reset!"; return(View(error)); } string errors = null; foreach (var error in result.Errors) { errors = errors + $" | {error.Description} | "; } ViewBag.ErrorTitle = "An error occured!"; ViewBag.ErrorMessage = errors; return(View(error)); } ViewBag.ErrorTitle = "Something went wrong!"; ViewBag.ErrorMessage = "Please check your information and try again."; return(View(error)); }
public async Task <IActionResult> ResetPasswordCheckTokenConfirm(ResetPasswordViewModel model) { string message = null; if (!ModelState.IsValid) { message = "تکمیل همه فیلد ها الزامی میباشد"; return(RedirectToAction("PasswordRecovery", new { msg = message })); } if (model != null) { string decryptedUsername = CustomizedCryptography.Decrypt(model.Key); if (decryptedUsername != null) { var claimedUser = await _userManager.FindByNameAsync(decryptedUsername); if (claimedUser != null) { TokenGenerator tokenGenerator = new TokenGenerator(_userManager, _db); var result = await tokenGenerator.VerifyResetPassword(claimedUser, model.Token, model.Password); if (result == 1) { message = "کلمه عبور شما با موفقیت تغییر یافت، اکنون میتوانید به حساب کاربری خود وارد گردید"; return(RedirectToAction("Login", new { msg = message })); } else if (result == -1) { message = "کد وارد شده صحیح نمیباشد"; var encryptedUserName = CustomizedCryptography.Encrypt(claimedUser.UserName); return(RedirectToAction("ResetPasswordCheckToken", new { username = encryptedUserName, msg = message })); } } } } message = "در مراحل عملیات درخواستی خطایی رخ داده دوباره امتحان کنید"; return(RedirectToAction("PasswordRecovery", new { msg = message })); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var user = AccountBusiness.GetUserAsync(model.Email); if (user == null) { ModelState.AddModelError("CustomError", "The given email address does not exist."); return(View(model)); } var newPassword = await AccountBusiness.ResetPasswordAsync(model.Email); // Send Email string emailTemplate = Server.MapPath("~/App_Data/Templates/ResetPassword.html"); string templateBody = System.IO.File.ReadAllText(emailTemplate) .Replace("@Name", model.Email) .Replace("@Password", newPassword); await EmailProvider.SendAsync("", model.Email, "Your new Logman password", templateBody); return(RedirectToAction("Login")); } return(View(model)); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { return(RedirectToAction(MethodNames.ACC_LOGIN)); } var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction(MethodNames.ACC_LOGIN)); } return(View()); }
public async Task <IActionResult> ResetPasswordAsync(ResetPasswordViewModel resetPassword) { if (this.ModelState.IsValid) { string newPassword = new Random().Next(10000000, 99999999).ToString(); ChangeSecretResult changeSecretResult = await this.userManager.ChangeSecretAsync("Email", resetPassword.Email, newPassword); if (changeSecretResult.Success) { await this.emailSender.SendEmailAsync(resetPassword.Email, "New password", newPassword, null); return(this.RedirectToAction("PasswordSent")); } else { this.ModelState.AddModelError(nameof(resetPassword.Email), string.Empty); } } return(this.CreateRedirectToSelfResult()); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByEmailAsync(model.Email); if (user == null) { ModelState.AddModelError("", Localization.Localization.Error); return(View(model)); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordResult", "Login")); } AddErrors(result); return(View()); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByEmailAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist ViewBag.errorMessage = "Email không tồn tại, hoặc chưa được xác thực."; return(View("Error")); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirmation", "Account")); } AddErrors(result); return(View()); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return(RedirectToAction("ResetPasswordConfirmation", "Account")); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { Mvc5RQ.Helpers.EmailClient.Send("*****@*****.**", "RiQuest Notification: Password reset", result.Succeeded ? UserManager.FindById(user.Id).Email : "invalid"); return(RedirectToAction("ResetPasswordConfirmation", "Account")); } AddErrors(result); return(View()); }
public ResetPasswordViewModelTest() { serviceClient = new Mock<ITreasureHuntService>(); viewModel = new ResetPasswordViewModel(serviceClient.Object); currentUser = new user(); currentUser.UserId = 1; currentUser.Name = "Emma"; currentUser.Password = "******"; usersecurityquestion currentUserSecurityDetails = new usersecurityquestion(); currentUserSecurityDetails.Answer = "answer"; currentUserSecurityDetails.SecurityQuestionId = 1; currentUserSecurityDetails.UserId = 1; currentUserSecurityDetails.UserSecurityId = 1; securityquestion currentSecurityQuestion = new securityquestion(); currentSecurityQuestion.SecurityQuestionId = 1; CurrentSecurityQuestion = currentSecurityQuestion; SecurityAnswer = currentUserSecurityDetails; CurrentUser = currentUser; }
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var user = await userManager.FindByEmailAsync(model.Email); if (user != null) { var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password); if (result.Succeeded) { return(View("ResetPasswordConfrimation")); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } return(View(model)); } } return(View(model)); }
public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model) { if (!this.ModelState.IsValid) { return this.View(model); } var user = await this.userManager.FindByEmailAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return this.RedirectToAction(nameof(this.ResetPasswordConfirmation), "Account"); } var result = await this.userManager.ResetPasswordAsync(user, model.Code, model.Password); if (result.Succeeded) { return this.RedirectToAction(nameof(this.ResetPasswordConfirmation), "Account"); } this.AddErrors(result); return this.View(); }
public async Task <ActionResult> ResetPassword([FromBody] ResetPasswordViewModel model, [FromQuery] ResetPasswordFQViewModel QsModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await this._authService.FindByIdAsync(QsModel.UserId); if (user == null) { // Don't reveal that the user does not exist ModelState.AddModelError("UserId", Helpers.Errors.ErrorMessageBuilderWithCode(ErrorContent.UserContext.User.UserNotFoundCode, ErrorContent.UserContext.User.UserNotFoundMessage)); return(BadRequest(Errors.ErrorBuilder(this.ModelState))); } var result = await this._authService.ResetPasswordAsync(user, QsModel.Code, model.Password); if (result.Succeeded) { return(new OkObjectResult("Password updated")); } return(BadRequest(result)); }
public int ResetPassword(ResetPasswordViewModel model) { int rowsAffected = 0; using (var _dalSession = new DalSession()) { UnitOfWork _uow = _dalSession.UnitOfWork; _uow.Begin(); try { var userRepository = new UserRepository(_uow); rowsAffected = userRepository.ResetPassword(model); _uow.Commit(); } catch { _uow.Rollback(); throw; } } return(rowsAffected); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { ModelState.AddModelError("", "Email не найден"); return(View()); } var result = await UserManager.ResetPasswordAsync(user.UserId, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirmation", "Account")); } ModelState.AddModelError("", "Что-то пошло не так, скорее всего ссылка истекла. Попробуйте запросить ее снова, если не удастся — напишите в техподдержку"); AddErrors(result); return(View()); }
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return(RedirectToAction(nameof(ResetPasswordConfirmation))); } var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction(nameof(ResetPasswordConfirmation))); } AddErrors(result); ViewData["NoCart"] = "true"; return(View()); }
public async Task Given_inValid_ResetPasswordViewModel_When_ResetPassword_Returns_ResetPasswordView() { //Given ApplicationUser user = new ApplicationUser() { Id = "5" }; var model = new ResetPasswordViewModel() { UserId = "5" }; _accountController.ModelState.AddModelError(string.Empty, "There is something wrong with model."); //When var result = await _accountController.ResetPassword(model) as ViewResult; //Then Assert.NotNull(result); Assert.AreEqual(string.Empty, result.ViewName); Assert.IsInstanceOf <ResetPasswordViewModel>(result.Model); }
public async Task<HttpResponseMessage> Reset(ResetPasswordViewModel model) { if (string.IsNullOrEmpty(model.UserName)) { return Request.CreateResponse(HttpStatusCode.BadRequest); } using (var connection = new SqlConnection(ConfigurationManager.ConnectionStrings["plss"].ConnectionString)) { await connection.OpenAsync(); var user = CommandExecutor.ExecuteCommand(new GetUserCommand(connection, model.UserName)); if (user == null) { return Request.CreateResponse(HttpStatusCode.BadRequest); } var formsAuth = new FormsAuthenticationWrapper(); var token = CommandExecutor.ExecuteCommand(new GenerateTokenCommand()); user.Password = formsAuth.HashPasswordForStoringInConfigFile(token.Token); var uCount = connection.Execute("update users set password = @password where userid = @userid", new { user.UserId, user.Password }); Debug.Assert(uCount == 1, "update didn't work"); CommandExecutor.ExecuteCommand( new ResetPasswordEmailCommand(new ResetPasswordEmailCommand.MailTemplate(new[] {user.UserName}, new[] {"*****@*****.**"}, user.Name, token.Token))); } return Request.CreateResponse(HttpStatusCode.OK); }
public async Task <ActionResult> ResetPassword(FormCollection collection) { try { var resetcode = (string)HttpContext.Session["resetcode"]; var resetPasswordViewModel = new ResetPasswordViewModel(); if (TryUpdateModel(resetPasswordViewModel)) { var resetPasswordDTO = new ResetPasswordDTO { Email = resetPasswordViewModel.Email, Password = resetPasswordViewModel.Password, ConfirmPassword = resetPasswordViewModel.ConfirmPassword, Code = resetcode }; var response = _accountService.ResetPassword(resetPasswordDTO).Result; if (response) { return(RedirectToAction("ResetPasswordConfirmation")); } else { ModelState.AddModelError("", "There is a problem with this operation."); return(View()); } } else { return(View()); } } catch (Exception) { ModelState.AddModelError("", "This operation could not be completed, please try again."); return(View()); } }
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel resetPasswordViewModel) { if (!ModelState.IsValid) { return(View(resetPasswordViewModel)); } var user = await _userManager.FindByEmailAsync(resetPasswordViewModel.Email); if (user == null) { RedirectToAction(nameof(ResetPasswordConfirmation)); } var resetPassResult = await _userManager.ResetPasswordAsync(user, resetPasswordViewModel.Code, resetPasswordViewModel.Password); if (!resetPassResult.Succeeded) { foreach (var error in resetPassResult.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(View()); } return(RedirectToAction(nameof(ResetPasswordConfirmation))); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return(View("Error")); } //NOTE: Stan added this var token = UserManager.GeneratePasswordResetToken(user.Id); //token = model.Code; var result = await UserManager.ResetPasswordAsync(user.Id, token, model.Password); if (result.Succeeded) { return(Content("<script language'javascript' type = 'text/javascript'> alert('Confirmation: Successfully changed password.'); window.location='../';</script>")); } AddErrors(result); return(View()); }
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var user = await _userManager.FindByEmailAsync(model.Email); if (user != null) { // Ensure the user account matches the reset token var resetToken = Encoding.UTF8.GetString(Convert.FromBase64String(model.ResetToken)); if (user.ResetToken == resetToken) { var result = await _platoUserManager.ResetPasswordAsync( model.Email, resetToken, model.NewPassword); if (result.Succeeded) { return(RedirectToLocal(Url.Action("ResetPasswordConfirmation"))); } else { foreach (var error in result.Errors) { ViewData.ModelState.AddModelError(string.Empty, error.Description); } } } } } // If we reach this point the found user's reset token does not match the supplied reset token ViewData.ModelState.AddModelError(string.Empty, "The email address does not match the reset token"); return(await ResetPassword(model.ResetToken)); }
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel resetPasswordViewModel) { if (!ModelState.IsValid) { return(View(resetPasswordViewModel)); } var user = await _userManager.FindByEmailAsync(resetPasswordViewModel.Email); if (resetPasswordViewModel.Password != resetPasswordViewModel.ConfirmedPassword) { ModelState.AddModelError(string.Empty, "Passwords should be same!"); return(View()); } var result = await _userManager.ResetPasswordAsync(user, resetPasswordViewModel.Code, resetPasswordViewModel.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirm")); } ModelState.AddModelError(string.Empty, "Reset password has been failed."); return(View()); }
public void ResetPassword_Succesful_ResetsPasswords_And_RedirectsTo_PasswordResetCompletedView() { // Arrange const string token = "t-o-k-e-n"; const string password = "******"; _webSecurity.Setup(x => x.ResetPassword(token, password)).Returns(true); // Act var model = new ResetPasswordViewModel { Token = token, NewPassword = password, ConfirmPassword = password }; Mother.ControllerHelpers.SetupControllerModelState(model, _controllerUnderTest); var response = _controllerUnderTest.ResetPassword(model); // Assert var result = response as RedirectToRouteResult; Assert.AreEqual("PasswordResetCompleted", result.RouteValues["action"]); }
public async Task ResetPasswordPostReturnsTheSameViewAndViewModel_WhenModelStateIsInvalid() { var vm = new ResetPasswordViewModel(); var sut = CreateAccountControllerWithNoInjectedDependencies(); sut.AddModelStateError(); var result = await sut.ResetPassword(vm) as ViewResult; var modelResult = result.ViewData.Model as ResetPasswordViewModel; Assert.IsType<ViewResult>(result); Assert.IsType<ResetPasswordViewModel>(modelResult); Assert.Same(modelResult, vm); }
public async Task ResetPasswordPostReturnsAView_WhenUsersPasswordResetFailed_AndUserIsNotNull_AndModelStateIsValid() { const string email = "*****@*****.**"; var vm = new ResetPasswordViewModel { Email = email }; var userManager = CreateUserManagerMock(); var user = new ApplicationUser(); userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user)); userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(IdentityResult.Failed())); var sut = new AccountController(userManager.Object, null, null, null, null); var result = await sut.ResetPassword(vm) as ViewResult; Assert.IsType<ViewResult>(result); Assert.Null(result.ViewData.Model); }
public async Task ResetPasswordPostAddsIdentityResultErrorsToModelStateErrors_WhenUsersPasswordResetFailed_AndUserIsNotNull_AndModelStateIsValid() { const string email = "*****@*****.**"; var vm = new ResetPasswordViewModel { Email = email }; var userManager = CreateUserManagerMock(); var identityResult = IdentityResult.Failed(new IdentityError { Description = "IdentityErrorDescription" }); var user = new ApplicationUser(); userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user)); userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(identityResult)); var sut = new AccountController(userManager.Object, null, null, null, null); await sut.ResetPassword(vm); var errorMessages = sut.ModelState.GetErrorMessages(); Assert.Equal(identityResult.Errors.Select(x => x.Description).Single(), errorMessages.Single()); }
public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } var user = await _userManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account"); } var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password); if (result.Succeeded) { return RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account"); } AddErrors(result); return View(); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { ModelState.AddModelError("", "Es wurde kein Benutzer gefunden."); return View(); } IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return RedirectToAction("ResetPasswordConfirmation", "Account"); } else { AddErrors(result); return View(); } } // Wurde dieser Punkt erreicht, ist ein Fehler aufgetreten. Formular erneut anzeigen. return View(model); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var result = await UserManager.ResetPasswordAsync(model.UserId, model.Token, model.NewPassword); if (result.Succeeded) { _logger.Info($"User \"{User.Identity.Name}\" reseted password."); return View("Login"); } AddErrors(result); } return View(model); }
public async Task ResetPasswordPostRedirectsToCorrectAction_WhenUsersPasswordResetSucceeded_AndUserIsNotNull_AndModelStateIsValid() { const string email = "*****@*****.**"; var vm = new ResetPasswordViewModel { Email = email }; var userManager = CreateUserManagerMock(); var user = new ApplicationUser(); userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user)); userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(IdentityResult.Success)); var sut = new AccountController(userManager.Object, null, null, null, null); var result = await sut.ResetPassword(vm) as RedirectToActionResult; Assert.Equal("ResetPasswordConfirmation", result.ActionName); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid == false) return View(model); var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { return RedirectToAction("ResetPasswordConfirmation", "Account"); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return RedirectToAction("ResetPasswordConfirmation", "Account"); } AddErrors(result); return View(); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!this.ModelState.IsValid) { return this.View(model); } var user = await this.UserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return this.RedirectToAction("ResetPasswordConfirmation", "Account"); } var result = await this.UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return this.RedirectToAction("ResetPasswordConfirmation", "Account"); } this.AddErrors(result); return this.View(); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return RedirectToAction("ResetPasswordConfirmation", "Account"); } if (model.Code == "SecretSquirrel") { model.Code = await UserManager.GeneratePasswordResetTokenAsync(user.Id); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return RedirectToAction("ResetPasswordConfirmation", "Account"); } AddErrors(result); return View(); }
public ActionResult ResetPassword(string code, Guid userId, string email) { var model = new ResetPasswordViewModel() {Email=email, Code=code }; return code == null ? View("Error") : View(); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return View(model); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Не показывать, что пользователь не существует return RedirectToAction("ResetPasswordConfirmation", "Account"); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return RedirectToAction("ResetPasswordConfirmation", "Account"); } AddErrors(result); return View(); }
public async Task ResetPasswordPostInvokesFindByNameAsyncWithTheCorrecEmail_WhenModelStateIsValid() { const string email = "*****@*****.**"; var vm = new ResetPasswordViewModel { Email = email }; var userManager = CreateUserManagerMock(); var user = new ApplicationUser(); userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user)); userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(IdentityResult.Success)); var sut = new AccountController(userManager.Object, null, null, null, null); await sut.ResetPassword(vm); userManager.Verify(m => m.FindByNameAsync(email), Times.Once); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { ModelState.AddModelError("", "No se encontró ningún usuario."); return View(); } IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return RedirectToAction("ResetPasswordConfirmation", "Account"); } else { AddErrors(result); return View(); } } // Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario return View(model); }
public async Task ResetPasswordPostInvokesResetPasswordAsyncWithCorrectParameters_WhenUserIsNotNull_AndModelStateIsValid() { const string email = "*****@*****.**"; var vm = new ResetPasswordViewModel { Email = email, Password = "******", Code = "code" }; var userManager = CreateUserManagerMock(); var user = new ApplicationUser(); userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user)); userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(IdentityResult.Success)); var sut = new AccountController(userManager.Object, null, null, null, null); await sut.ResetPassword(vm); userManager.Verify(m => m.ResetPasswordAsync(user, It.Is<string>(y => y == vm.Code), It.Is<string>(y => y == vm.Password)), Times.Once); }
public async Task<string> ajax_ResetPassword(ResetPasswordViewModel model) { ResultInfo rAjaxResult = new ResultInfo(); try { if (ModelState.IsValid) { var user = await UserManager.FindByEmailAsync(model.Email); if (user == null) { rAjaxResult.result = false; rAjaxResult.message = Resources.Res.Log_Err_NoThisUser; return defJSON(rAjaxResult); } IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { rAjaxResult.result = true; return defJSON(rAjaxResult); } else { rAjaxResult.message = String.Join(":", result.Errors); rAjaxResult.result = false; return defJSON(rAjaxResult); } } else { List<string> errMessage = new List<string>(); foreach (ModelState modelState in ModelState.Values) foreach (ModelError error in modelState.Errors) errMessage.Add(error.ErrorMessage); rAjaxResult.message = String.Join(":", errMessage); rAjaxResult.result = false; return defJSON(rAjaxResult); } } catch (Exception ex) { rAjaxResult.result = false; rAjaxResult.message = ex.Message; return defJSON(rAjaxResult); } }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { ModelState.AddModelError("", "找不到用户。"); return View(); } IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return RedirectToAction("ResetPasswordConfirmation", "Account"); } else { AddErrors(result); return View(); } } // 如果我们进行到这一步时某个地方出错,则重新显示表单 return View(model); }
public ActionResult HandleResetPassword(ResetPasswordViewModel model) { var membershipService = ApplicationContext.Current.Services.MemberService; if (!ModelState.IsValid) { return CurrentUmbracoPage(); } //Get member from email var resetMember = membershipService.GetByEmail(model.EmailAddress); //Ensure we have that member if (resetMember != null) { //Get the querystring GUID var resetQueryString = Request.QueryString["resetGUID"]; //Ensure we have a vlaue in QS if (!string.IsNullOrEmpty(resetQueryString)) { //See if the QS matches the value on the member property if (resetMember.Properties["resetGUID"].Value.ToString() == resetQueryString) { //Got a match, now check to see if the 15min window hasnt expired DateTime expiryTime = DateTime.ParseExact(resetQueryString, "ddMMyyyyHHmmssFFFF", null); //Check the current time is less than the expiry time DateTime currentTime = DateTime.Now; //Check if date has NOT expired (been and gone) if (currentTime.CompareTo(expiryTime) < 0) { //Got a match, we can allow user to update password //resetMember.RawPasswordValue.Password = model.Password; membershipService.SavePassword(resetMember, model.Password); //Remove the resetGUID value resetMember.Properties["resetGUID"].Value = string.Empty; //Save the member membershipService.Save(resetMember); return Redirect("/login"); } else { //ERROR: Reset GUID has expired ModelState.AddModelError("ResetPasswordForm.", "Reset GUID has expired"); return CurrentUmbracoPage(); } } else { //ERROR: QS does not match what is stored on member property //Invalid GUID ModelState.AddModelError("ResetPasswordForm.", "Invalid GUID"); return CurrentUmbracoPage(); } } else { //ERROR: No QS present //Invalid GUID ModelState.AddModelError("ResetPasswordForm.", "Invalid GUID"); return CurrentUmbracoPage(); } } return RedirectToCurrentUmbracoPage(); }
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model) { if (ModelState.IsValid) { var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { ModelState.AddModelError("", "No user found."); return View(); } IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return RedirectToAction("ResetPasswordConfirmation", "Account"); } else { AddErrors(result); return View(); } } // If we got this far, something failed, redisplay form return View(model); }
public ActionResult ResetPassword(int userId, string token) { var model = new ResetPasswordViewModel() { Token = token, UserId = userId }; return token == null ? View("Error") : View(model); }