public ActionResult ConfirmarRedefinicaoSenha() { ResetPasswordModel pageModel = new ResetPasswordModel(); this.BindBasePageModel(pageModel); pageModel.ResetPasswordData = new ResetPasswordData(); pageModel.ResetPasswordData.PasswordVerificationToken = Request.QueryString["token"]; return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/ConfirmarRedefinicaoSenha", pageModel); }
public async void HttpPost_ResetPassword_ModelIsInvalid_ReturnsViewWithModel() { var passwordResetModel = new ResetPasswordModel(); var controller = AccountController(); controller.ModelState.AddModelError("Some model property", "Some error occurred"); var result = await controller.ResetPassword(A.Dummy<Guid>(), A.Dummy<string>(), passwordResetModel); Assert.IsType<ViewResult>(result); Assert.Equal(passwordResetModel, ((ViewResult)result).Model); }
public ActionResult ConfirmarRedefinicaoSenhaPost(ResetPasswordModel model) { ResetPasswordModel pageModel = new ResetPasswordModel(); this.BindBasePageModel(pageModel); try { customerAPIClient.ResetPasswordWithToken(new ResetPasswordData() { PasswordVerificationToken = model.ResetPasswordData.PasswordVerificationToken, NewPassword = model.ResetPasswordData.NewPassword }); } catch (Exception ex) { ViewBag.Error = ex.Message; return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/ConfirmarRedefinicaoSenha", pageModel); } ViewBag.Error = "Senha alterada com sucesso."; ViewBag.Sucesso = "1"; return RedirectToAction("Index"); }
public async void HttpPost_ResetPassword_ModelIsValid_CallsApiToResetPassword() { var passwordResetModel = new ResetPasswordModel(); A.CallTo(() => unauthenticatedUserClient.ResetPasswordAsync(A<PasswordResetData>._)) .Returns(true); A.CallTo(() => weeeAuthorization.SignIn(A<string>._, A<string>._, A<bool>._)) .Returns(LoginResult.Success("dshjkal", A.Dummy<ActionResult>())); A.CallTo(() => apiClient.User) .Returns(unauthenticatedUserClient); await AccountController().ResetPassword(A.Dummy<Guid>(), A.Dummy<string>(), passwordResetModel); A.CallTo(() => unauthenticatedUserClient.ResetPasswordAsync(A<PasswordResetData>._)) .MustHaveHappened(Repeated.Exactly.Once); }
public async Task <IActionResult> ResetPassword(ResetPasswordModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { return(RedirectToAction("Home", "Index")); } var result = await _userManager.ResetPasswordAsync(user, model.Token, model.Password); if (result.Succeeded) { return(RedirectToAction("Login", "Account")); } return(View(model)); }
public async Task <IHttpActionResult> ResetPassword(ResetPasswordModel model) { if (String.IsNullOrEmpty(model?.PasswordResetToken)) { return(BadRequest("Invalid Password Reset Token.")); } var user = await _userRepository.GetByPasswordResetTokenAsync(model.PasswordResetToken); if (user == null) { return(BadRequest("Invalid Password Reset Token.")); } if (!user.HasValidPasswordResetTokenExpiration()) { return(BadRequest("Password Reset Token has expired.")); } if (!IsValidPassword(model.Password)) { return(BadRequest(_invalidPasswordMessage)); } user.MarkEmailAddressVerified(); await ChangePassword(user, model.Password); // TODO: use last logged in org var organizationId = user.Memberships.Count > 0 ? user.Memberships.First().OrganizationId : null; if (user.IsAdmin(organizationId)) { await _organizationService.TryMarkOrganizationAsVerifiedAsync(organizationId); } ExceptionlessClient.Default.CreateFeatureUsage("Reset Password").AddObject(user).Submit(); return(Ok(new TokenResponseModel { Token = await GetToken(user, organizationId) })); }
public ActionResult ResetPassword(string id) { try { var model = new ResetPasswordModel(); if (Request["result"] == "success") { return(View(model)); } var RequestID = id; if (RequestID == null) { return(RedirectToAction("ForgetPassword")); } string ConnectionString = WebConfigurationManager.ConnectionStrings["MainDB"].ConnectionString; if (ConnectionString == null) { throw new Exception("Invalid Server Setting. Please contact IT support to update Web.config."); } var req = new Request(); using (var db = new Database(new SqlConnection(ConnectionString))) { db.Connection.Open(); req = db.FirstOrDefault <Request>("where RequestID = @RequestID", new { RequestID = RequestID }); db.Connection.Close(); } model.UserPrincipalName = req.UserID; model.RequestID = req.RequestID; return(View(model)); } catch (Exception ex) { ModelState.AddModelError("ActiveDirectory", ex.Message); var model = new ResetPasswordModel(); return(View(model)); } }
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordModel model) { var validateTokenResult = await ValidateToken(model.Token); if (!validateTokenResult.IsValidToken) { _log.Warning($"Invalid token provided: {model.Token}"); return(BadRequest(ErrorResponse.Create("Invalid token"))); } try { var employee = await _payInvoiceClient.GetEmployeeAsync(validateTokenResult.ResetPasswordToken.EmployeeId); await _payAuthClient.UpdateAsync(new UpdateCredentialsModel { Email = employee.Email, EmployeeId = employee.Id, MerchantId = employee.MerchantId, Password = model.Password }); await _payAuthClient.RedeemResetPasswordTokenAsync(model.Token); } catch (Exception e) { _log.Error(e, $"Error occured for token: {model.Token}"); return(BadRequest(ErrorResponse.Create("Error occured"))); } if (User.Identity.IsAuthenticated) { await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme); } _log.Info($"ResetPassword success for token {model.Token} by {HttpContext?.Connection?.RemoteIpAddress?.ToString().SanitizeIp()}"); return(Ok()); }
public async Task <IActionResult> ResetPassword(ResetPasswordModel resetPasswordModel) { const string _error = "Reset password has been failed!"; if (!Infrastructure.Extensions.TryFromBase64String(resetPasswordModel.ResetToken, out var resetTokenArray)) { return(BadRequest(_error)); } var unprotectedResetTokenArray = _dataProtector.Unprotect(resetTokenArray); var userIdInput = string.Empty; using (var ms = new MemoryStream(unprotectedResetTokenArray)) using (var reader = new BinaryReader(ms)) { reader.ReadInt64(); userIdInput = reader.ReadString(); } if (!Guid.TryParse(userIdInput, out var _)) { return(BadRequest(_error)); } var user = await _userManager.FindByIdAsync(userIdInput); if (user == null) { return(BadRequest(_error)); } var result = await _userManager.ResetPasswordAsync(user, resetPasswordModel.ResetToken, resetPasswordModel.Password); if (!result.Succeeded) { return(BadRequest(_error)); } return(Ok()); }
public async Task <object> ResetPassword([FromBody] ResetPasswordModel model) { if (!ModelState.IsValid) { return(new { success = false, errors = GetModelState() }); } var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return(new { success = true }); } var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password); if (result.Succeeded) { return(new { success = true }); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } return(new { success = false, errors = GetModelState() }); }
public ActionResult ResetPassword(ResetPasswordModel model) { //validate model, set new password if (ModelState.IsValid) { try { model.Code = Request.Params["prc"]; AccountService.ResetPassword(model); return(RedirectToAction("Index", "Home", new { })); } catch (ReturnEmailNotFoundException ex) { return(RedirectToAction("InvalidUrl", "Content")); } } else { return(View(model)); } }
public ActionResult ResetPassword(ResetPasswordModel model) { string hashedPassword = null; MembershipService service = new MembershipService(); ActionResult result = null; if (ModelState.IsValid) { hashedPassword = service.EseguiHashPassword(model.Password); UtenteRepository.Instance.AggiornaPassword(model.UtenteId, hashedPassword); result = RedirectToAction("Index", "Home"); } else { model.TokenValido = true; result = View(model); } return(result); }
public ActionResult ResetPassword(string token) { if (string.IsNullOrEmpty(token)) { throw new HttpException((int)HttpStatusCode.NotFound, "not found"); } ResetPasswordRequest request = _membershipService.GetActivePasswordResetRequestByToken(token); if (request == null) { throw new HttpException((int)HttpStatusCode.NotFound, "not found"); } ResetPasswordModel model = new ResetPasswordModel(); model.Init(_membershipService.MinPasswordLength); model.Token = request.Token; return(View(model)); }
// Reset Password public bool ResetPassword(ResetPasswordModel resetPassword) { UserModel isUserExists = new UserModel(); try { isUserExists = CheckUserExists(resetPassword.email); if (isUserExists != null) { isUserExists.password = resetPassword.password; isUserExists.updatedAt = DateTime.Now; _userRepository.Update(isUserExists); return(true); } } catch (Exception ex) { string msg = ex.Message; } return(false); }
// 10.Reset Password public ActionResult ResetPassword(string id) { // Verify the reset password link // Find Account associated with this link // Redirect to reset password page using (UserDBContext db = new UserDBContext()) { var user = db.Users.Where(x => x.ResetPasswordCode == id).FirstOrDefault(); if (user != null) { ResetPasswordModel model = new ResetPasswordModel(); model.ResetCode = id; return(View(model)); } else { return(HttpNotFound()); } } }
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordModel model) { #region Validate Model var userInputValidated = _resetPasswordValidator.Validate(model); if (!userInputValidated.IsValid) { _infos.Add(_badRequest.ShowError(int.Parse(userInputValidated.Errors[0].ErrorMessage)).Message); return(BadRequest(new CustomResponse <string> { Message = _infos })); } #endregion var resetPassword = await _user.ResetPassword(model); return(Ok(resetPassword)); }
public ActionResult ResetPassword(ResetPasswordModel resetPasswordModel) { if (ModelState.IsValid) { //TODO: userId ignored as we only allow users to reset their own passwords MembershipUser currentUser = Membership.GetUser(resetPasswordModel.Username); if (currentUser != null) { currentUser.UnlockUser(); string newPassword = currentUser.ResetPassword(); SendPasswordResetEmail(currentUser.Email, newPassword); TempData["isSuccessReset"] = true; return(RedirectToAction("Logon")); } else { ModelState.AddModelError("Username", "Username not found."); } } return(View(resetPasswordModel)); }
public ActionResult ResetPassword(ResetPasswordModel model) { if (ModelState.IsValid) { using (ELearningDB db = new ELearningDB()) { var user = db.TaiKhoans.Find(model.ID); if (model.AuthenticationCode != user.NguoiDung.MaXacNhan) { ViewBag.ResetPass = "******"; return(View(model)); } user.Password = Encryptor.MD5Hash(model.Password); user.NguoiDung.MaXacNhan = null; db.SaveChanges(); TempData["ResetPass"] = "******"; return(RedirectToAction("Index")); } } return(View(model)); }
public async Task <User> ResetPassword(ResetPasswordModel model) { User dbUser = await GetUserById(model.UserId); if (dbUser.ResetPasswordToken != model.Token || DateTimeOffset.UtcNow >= dbUser.ResetPasswordExpirationDate) { throw new Exception("This reset password token is invalid or has expired. Please try again later."); } string salt = Helpers.CreateUniqueString(64); dbUser.UpdatedDate = DateTimeOffset.Now; dbUser.ResetPasswordToken = null; dbUser.ResetPasswordExpirationDate = null; dbUser.Salt = salt; dbUser.PasswordHash = model.Password.Encrypt(salt); await Context.SaveChangesAsync(); return(dbUser); }
public ActionResult ResetPassword(ResetPasswordModel model) { if (ModelState.IsValid) { using (var db = new BonoboGitServerContext()) { var user = db.Users.FirstOrDefault(x => x.Username.Equals(model.Username, StringComparison.OrdinalIgnoreCase)); if (user == null) { TempData["ResetSuccess"] = false; Response.AppendToLog("FAILURE"); } else { MembershipService.UpdateUser(model.Username, user.Name, user.Surname, user.Email, model.Password); TempData["ResetSuccess"] = true; } } } return(View(model)); }
//verify the reset Passworrd link public ActionResult ResetPassword(string resetPassCode) { //verify the reset pass link //find account associated with that link //redirect to reset password page using (LoginContext context = new LoginContext()) { var user = context.Users.Where(u => u.ResetPasswordCode == resetPassCode).FirstOrDefault(); if (user != null) { ResetPasswordModel resetModel = new ResetPasswordModel(); resetModel.ResetCode = resetPassCode; return(View(resetModel)); } else { return(HttpNotFound()); } } }
public ActionResult ResetPassword(string id) { //Verify the reset password link //Find account associated with this link //redirect to reset password page using (MyDatabaseEntities dc = new MyDatabaseEntities()) { var user = dc.Users.Where(a => a.ResetPasswordCode == id).FirstOrDefault(); if (user != null) { ResetPasswordModel model = new ResetPasswordModel(); model.ResetCode = id; return(View(model)); } else { return(HttpNotFound()); } } }
internal async Task <HttpResponseMessage> ResetPassword(ResetPasswordModel resetPassword) { var url = $"{_Config.Value.Okta_OrgUri}/api/v1/users/{resetPassword.UserId}"; var postValue = new { credentials = new { password = new { value = resetPassword.Password } } }; var data = new ByteArrayContent(System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(postValue))); client.DefaultRequestHeaders.Clear(); client.DefaultRequestHeaders.Add("Accept", "application/json"); client.DefaultRequestHeaders.Add("Authorization", "SSWS " + _Config.Value.Okta_APIToken); data.Headers.ContentType = new MediaTypeHeaderValue("application/json"); return(await client.PutAsync(url, data)); }
public ActionResult ResetPassword(string id) { //varify reset password link //rediecrt to reset password page //find account accociadted with the link //check the uniquecode from db using (SurveyEntities db = new SurveyEntities()) { var user = db.Users.Where(a => a.ResetPassword == id).FirstOrDefault(); //find the account associated with this id if (user != null) //id is reset password code and we match it with the db reset pass code and if found user associated with this id { ResetPasswordModel mod = new ResetPasswordModel(); mod.ResetCode = id; //so valide id when submit rest password form return(View(mod)); // here code for the user can see the rset password view } else { return(HttpNotFound());// error for invalid link } } }
public async Task <IActionResult> ResetPassword(ResetPasswordModel resetPasswordModel) { var token = await this.accountBL.ResetPassword(resetPasswordModel); string message = string.Empty; bool success = false; if (token) { success = true; message = "Password changed successfully "; return(this.Ok(new { success, message })); } else { success = false; message = "Password Reset Failed"; return(this.BadRequest(new { success, message })); } }
public ActionResult SubmitResetPassword(ResetPasswordModel model) { var data = new ActionOutput(); if (model.UserId > 0 && model.type == (int)UserTypes.User) { var result = _userManager.ChangePassword(model); if (result.Status == ActionStatus.Successfull) { data.Message = "Password reset successfully"; data.Status = ActionStatus.Successfull; } else { data.Message = "Error occured"; data.Status = ActionStatus.Error; } return(Json(data, JsonRequestBehavior.AllowGet)); } data.Message = "Unexpected error"; data.Status = ActionStatus.Error; return(Json(data, JsonRequestBehavior.AllowGet)); }
public ActionResult ResetPassword(string Token) { tblUser userModel = _dbRepository.GetEntities().FirstOrDefault(m => m.Token == Token); if (userModel.UserId > 0 && userModel.TokenExpiryDateTime >= DateTime.Now) { ResetPasswordModel model = new ResetPasswordModel { UserId = userModel.UserId }; return(View(model)); } if (userModel.TokenExpiryDateTime < DateTime.Now) { TempData[Enums.NotifyType.Error.GetDescription()] = "Token for reset password has been expired.please try again to reset password."; return(View("Index")); } TempData[Enums.NotifyType.Error.GetDescription()] = "Something Went wrong. Please try again later."; return(View("Index")); }
public async Task <IActionResult> ResetPassword(ResetPasswordModel model) { if (!ModelState.IsValid) { return(View(model)); } var response = await _accountsEndpoint.ResetPassword(model); if (response.Succeeded) { return(View("ResetPasswordConfirmation")); } //TODO Does this not leave us security vulnerable. i.e. Email/User exists? foreach (var error in response.Errors) { ModelState.AddModelError(string.Empty, error.Description); } return(View(model)); }
public async Task <IActionResult> ResetPassword(ResetPasswordModel model) { if (ModelState.IsValid) { model.Token = model.Token.Replace(' ', '+'); var result = await accountRepository.ResetPasswordAsync(model); if (result.Succeeded) { ModelState.Clear(); model.IsSuccess = true; return(View(model)); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(model)); }
public async Task <OperationResult> ResetPassword(ResetPasswordModel model) { if (!ModelState.IsValid) { var allErrors = ModelState.Values.SelectMany(v => v.Errors); return(new OperationResult(false, string.Join(" ", allErrors))); } var user = await UserManager.FindByIdAsync(model.UserId); if (user == null) { return(new OperationResult(false)); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(new OperationResult(true)); } return(new OperationResult(false, string.Join(" ", result))); }
public async Task <IActionResult> ResetPasswordAsync([FromBody] ResetPasswordModel model) { var user = await _userService.FindOneAsync(new UserFilter { ResetPasswordToken = model.Token, AsNoTracking = true }, x => new User { Id = x.Id }); if (user == null) { return(BadRequest(nameof(model.Token), "Password reset link has expired or invalid.")); } await _userService.UpdatePasswordAsync(user.Id, model.Password); return(Ok()); }
public bool ResetPassword(int id, ResetPasswordModel reset) { ResetPasswordModel password = new ResetPasswordModel { NewPassword = reset.NewPassword, ConfirmPassword = reset.ConfirmPassword, }; if (password.NewPassword == password.ConfirmPassword) { var dbUser = userContext.Users.FirstOrDefault(s => s.UserId == id); dbUser.Password = reset.NewPassword; userContext.SaveChanges(); return(true); } else { return(false); } }
public async Task <IActionResult> ResetPassword(ResetPasswordModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { return(RedirectToAction(nameof(ResetPasswordConfirmation))); } var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction(nameof(ResetPasswordConfirmation))); } AddErrors(result); return(View()); }
public ActionResult ResetPassword(string id) { //Verify the Resetcode //Find Account associate with the Link //Redirect to reset Password Page using (DataBaseContext db = new DataBaseContext()) { var user = db.Users.Where(a => a.ResetPasswordCode == id).FirstOrDefault(); if (user != null) { ResetPasswordModel model = new ResetPasswordModel(); model.ResetCode = id; return(View(model)); } else { return(HttpNotFound()); } } }
public virtual ActionResult ResetPasswordRespond(ResetPasswordModel model) { if ( ModelState.IsValid && AccountService.ResetPassword(model.Email, model.ResetCode, model.NewPassword) ) { // UserEventLogService.LogUserEvent(UserActions.ResetPassword); return RedirectToAction(Actions.LogIn()); } else { ModelState.AddModelError("", SystemErrors.PasswordResetFailed); ViewData["PasswordLength"] = AccountService.MinPasswordLength; model.NavigationLocation = new string[] { "Home", "ResetPassword" }; this.FeedbackError("There was an error processing your password reset request..."); return View(model); } }
public ActionResult ResetPassword(ResetPasswordModel model) { if (!string.IsNullOrEmpty(model.Email)) { // L'utilisateur existe ? var user = this.db.Users.FirstOrDefault(entry => entry.UserName == model.Email); if (user == null) { ModelState.AddModelError(string.Empty, "Votre email n'existe pas."); } else { var confirmationToken = this.GeneratePasswordResetToken(model.Email); if (string.IsNullOrEmpty(confirmationToken)) { ModelState.AddModelError(string.Empty, "Votre email n'existe pas."); } else { this.SendEmailReset(model.Email, confirmationToken); return this.RedirectToAction("ResetPasswordStepTwo"); } } } else { ModelState.AddModelError(string.Empty, "Email invalide."); } // Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire return this.View(model); }
public HttpResponseMessage ResetPassword(ResetPasswordModel model) { ActionOutput Result = _homeManager.ResetPassword(model); return Request.CreateResponse<ApiActionOutput>(HttpStatusCode.OK, new ApiActionOutput { Status = Result.Status, Message = Result.Message }); }
public async Task<HttpResponseMessage> ResetPassword(ResetPasswordModel model) { List<string> errors = new List<string>(); if (!ModelState.IsValid) { errors.AddRange(ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToList()); return Request.CreateResponse(HttpStatusCode.BadRequest, errors); } var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist errors.Add("Don't reveal that the user does not exist"); return Request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray()); } var result = await UserManager.ChangePasswordAsync(user.Id, model.SentPassword, model.NewPassword); if (result.Succeeded) { return Request.CreateResponse(HttpStatusCode.OK, user); } errors.Add("An error has occured while changing password."); return Request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray()); }
public ActionResult RedefinirSenhaPost(ResetPasswordModel model) { ResetPasswordModel pageModel = new ResetPasswordModel(); this.BindBasePageModel(pageModel); try { customerAPIClient.GeneratePasswordReset(new ResetPasswordData() { Email = model.ResetPasswordData.Email }); } catch (Exception ex) { ViewBag.Error = ex.Message; return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/RedefinirSenha", pageModel); } ViewBag.Error = "Siga as instruções no seu email."; ViewBag.Sucesso = "1"; return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/RedefinirSenha", pageModel); //return RedirectToAction("Index"); }
public async Task<ActionResult> ResetPassword(Guid id, string token, ResetPasswordModel model) { if (!ModelState.IsValid) { return View(model); } using (var client = apiClient()) { var passwordResetData = new PasswordResetData { Password = model.Password, Token = token, UserId = id }; try { bool result = await client.User.ResetPasswordAsync(passwordResetData); return View(!result ? "ResetPasswordExpired" : "ResetPasswordComplete"); } catch (ApiBadRequestException ex) { this.HandleBadRequest(ex); if (ModelState.IsValid) { throw; } AddRemoveModelStateErrors(); } return View(model); } }
ActionOutput IHomeManager.ResetPassword(ResetPasswordModel model) { int[] regvia = { (int)RegisterVia.Android, (int)RegisterVia.Website, (int)RegisterVia.IPhone }; User user = Context.Users.Where(m => m.Email == model.UserEmail).FirstOrDefault(); if (user == null) return new ActionOutput { Message = "User does not exists.", Status = ActionStatus.Error }; if (!user.ResetPassword) return new ActionOutput { Message = "User doesn't requested to reset the password.", Status = ActionStatus.Error }; if (user.PasswordResetCode != model.ResetCode) return new ActionOutput { Message = "Password reset code does not match.", Status = ActionStatus.Error }; if (!regvia.Contains(user.RegisterVia)) return new ActionOutput { Message = "Password can not be reset for facebook user.", Status = ActionStatus.Error }; user.ResetPassword = false; user.PasswordResetCode = null; user.Password = Utility.GetEncryptedValue(model.NewPassword); SaveChanges(); return new ActionOutput { Message = "Password has been reset.", Status = ActionStatus.Successfull }; }
public async Task<ActionResult> ResetPassword(Guid id, string token, ResetPasswordModel model) { if (!ModelState.IsValid) { return View(model); } using (var client = apiClient()) { var passwordResetData = new PasswordResetData { Password = model.Password, Token = token, UserId = id }; try { bool result = await client.User.ResetPasswordAsync(passwordResetData); return View(!result ? "ResetPasswordExpired" : "ResetPasswordComplete"); } catch (ApiBadRequestException ex) { this.HandleBadRequest(ex); if (ModelState.IsValid) { throw; } foreach (var modelState in ViewData.ModelState.Values.ToList()) { List<int> errorsToRemoveIndex = new List<int>(); for (var i = modelState.Errors.Count - 1; i >= 0; i--) { if (modelState.Errors[i].ErrorMessage.Contains("Passwords") && modelState.Value == null) { errorsToRemoveIndex.Add(i); } } foreach (int index in errorsToRemoveIndex) { modelState.Errors.RemoveAt(index); } } } return View(model); } }
public ActionResult ResetPassword(ResetPasswordModelWebsite model) { ResetPasswordModel reset = new ResetPasswordModel { NewPassword = model.Password, ResetCode = model.ResetCode, UserEmail = model.UserEmail }; return Json(_homeManager.ResetPassword(reset), JsonRequestBehavior.AllowGet); }
public async void HttpPost_ResetPassword_ModelIsValid_PasswordResetThrowsApiBadRequestExceptionWithModelErrors_ReturnsViewWithModel_AndErrorAddedToModelState() { // Arrange Dictionary<string, ICollection<string>> modelState = new Dictionary<string, ICollection<string>> { { "A Key", new List<string> { "Something wen't wrong" } } }; ApiBadRequestException badRequestException = new ApiBadRequestException(HttpStatusCode.BadRequest, new ApiBadRequest { ModelState = modelState }); IUnauthenticatedUser unauthenticatedUserClient = A.Fake<IUnauthenticatedUser>(); A.CallTo(() => unauthenticatedUserClient.ResetPasswordAsync(A<PasswordResetData>._)) .Throws(badRequestException); A.CallTo(() => apiClient.User) .Returns(unauthenticatedUserClient); AccountController controller = AccountController(); ResetPasswordModel passwordResetModel = new ResetPasswordModel(); // Act ActionResult result = await controller.ResetPassword(A.Dummy<Guid>(), A.Dummy<string>(), passwordResetModel); // Assert Assert.IsType<ViewResult>(result); Assert.Equal(passwordResetModel, ((ViewResult)result).Model); Assert.Single(controller.ModelState.Values); Assert.Single(controller.ModelState.Values.Single().Errors); Assert.Contains("Something wen't wrong", controller.ModelState.Values.Single().Errors.Single().ErrorMessage); }
public ActionResult ResetPassword(ResetPasswordModel model) { var errorMessage = String.Empty; if (!ModelState.IsValid) { return View(model); } // Try sending reset try { var question = WebSecurity.GetSecretQuestion(model.Email); } catch (MembershipPasswordException e) { errorMessage = e.Message; } if (String.IsNullOrEmpty(errorMessage)) { var success = WebSecurity.SendResetPassword(Request.Url.Host, model.Email, model.Answer); if (success) { return RedirectToAction("ResetPasswordSuccess"); } ModelState.AddModelError("", "The answer did not match our records"); return View(model); } ModelState.AddModelError("", errorMessage); return View(model); }
public virtual ActionResult ResetPassword(ResetPasswordModel model) { if (ModelState.IsValid) { model.ResetCode = model.Email.PasswordHashString(); //Send email string link = String.Format(@"visit our <a href='{0}/Account/ResetPasswordRespond/{1}?rc={2}'>Password Reset page</a>", SystemConfig.BaseUrl, model.Email, model.ResetCode); string msg = String.Format(SystemMessages.PasswordResetRequestLink, link); Mail.SendMail( String.Format("{0} <{1}>", SiteProfileData.SiteProfile().CompanyName, SystemConfig.AdminEmailAddress),// model.Email, SystemMessages.PasswordResetRequestSubjectLine, String.Format("{0} {1}", String.Format(SystemMessages.PasswordResetRequest, SiteProfileData.SiteProfile().CompanyName), msg) ); return RedirectToAction(Actions.ResetPasswordSuccess()); } ViewData["PasswordLength"] = AccountService.MinPasswordLength; model.NavigationLocation = new string[] { "Account", "ResetPassword" }; this.FeedbackError("There was an error processing your password reset request..."); return View(model); }
// ************************************** // URL: /Account/ResetPasswordRespond // ************************************** public virtual ActionResult ResetPasswordRespond(string id, string rc) { var model = new ResetPasswordModel() { Email = id, ResetCode = rc }; ViewData["PasswordLength"] = AccountService.MinPasswordLength; model.NavigationLocation = new string[] { "Account", "ResetPassword" }; return View(model); }
public ActionResult RedefinirSenha() { ResetPasswordModel pageModel = new ResetPasswordModel(); this.BindBasePageModel(pageModel); pageModel.ResetPasswordData = new ResetPasswordData(); return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/RedefinirSenha", pageModel); }
public ActionResult ForgetPassword(ResetPasswordModel model) { if (ModelState.IsValid) { User user = _securityService.GetUsers().Where(x => x.Email == model.UserEmail).FirstOrDefault(); if (user != null) { if (_securityService.ForgetPassword(user)) { //return RedirectToAction("Login", "Account"); const string returnStr = @"<div class='message-info'>Please, check you email for reset password.</div>"; return Content(returnStr); } else { return Content("Sorry, we could not find anyone with that email address!"); } } else { return Content("You are not valid user!"); } } else { return Content("Please review your form!"); } }