public async Task <IActionResult> Reset(Guid userId, string token) { var model = new ResetViewModel { UserId = userId, Token = token }; var user = await _userManager.FindByIdAsync(userId.ToString()); if (user is null) { model.Errors = new string[] { "Invalid user ID." }; } else { // https://stackoverflow.com/a/51651691 model.UserAndTokenAreValid = await _userManager.VerifyUserTokenAsync( user, _userManager.Options.Tokens.PasswordResetTokenProvider, UserManager <DejarixUser> .ResetPasswordTokenPurpose, token); if (!model.UserAndTokenAreValid) { model.Errors = new string[] { "Invalid token." } } ; } return(View(model)); }
public ActionResult Reset([Bind(Include = "NewPassword,ConfirmPassword,Key,Token")] ResetViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = UserManager.FindById(model.Key); if (user == null) { ModelState.AddModelError("", AuthResources.RequestMailNoUser); return(View(model)); } var result = UserManager.ResetPassword(user.Id, model.Token, model.NewPassword); if (!result.Succeeded) { AddErrors(result); return(View(model)); } SignInLogModel log = new SignInLogModel(); log.ClientIp = GetClientIp(); log.UserModelId = user.Id; log.UserCode = user.UserName; log.SetStatus(2); dbContext.SignInLogModels.Add(log); dbContext.SaveChanges(); UserManager.ResetAccessFailedCount(user.Id); return(View("ResetComplete")); }
public ActionResult Reset(ResetViewModel model) { if (!string.IsNullOrWhiteSpace(model.Password) && !string.IsNullOrWhiteSpace(model.ConfirmPassword)) { if (!model.Password.Equals(model.ConfirmPassword, StringComparison.Ordinal)) { ModelState.AddModelError("Confirmation", "The passwords you entered do not match."); } } if (!ModelState.IsValid) { return(View(model)); } var result = _tokenService.RedeemPasswordToken(model.Token, model.EmailAddress, model.Password); if (!string.IsNullOrWhiteSpace(result)) { ModelState.AddModelError("Execution", result); return(View(model)); } return(RedirectToAction(nameof(Index), "Home", new { area = "" })); }
public IActionResult Reset(ResetViewModel vm, string userid, string email, string token) { ViewData["status"] = ""; ValidateReset(vm, userid, email, token); if (ModelState.IsValid) { try { Auth0.ManagementApi.Models.User userResult = null; SalesforceService.Response hashResponse = SalesforceService.CheckHash(_sfdcTokenManager.instance_url, _sfdcTokenManager.access_token, System.Net.WebUtility.HtmlDecode(email), token).Result; _logger.LogInformation("Hash Code Response: {0}", hashResponse.code); _logger.LogInformation("User Id: {0}", userid); //Hash matches if (hashResponse.code == "10014") { string accessToken = GetClientToken().Result; userResult = UpdateUserPassword(accessToken, System.Net.WebUtility.HtmlDecode(userid), vm.NewPassword1).Result; ViewData["status"] = userResult.UpdatedAt; } else { ModelState.AddModelError("", "Token has expired"); } } catch (Exception e) { ModelState.AddModelError("", e.Message); } } return(View(vm)); }
public object Any(ResetViewModel request) { ValidationResult validations = new ResetAccountValidator().Validate(request); if (!validations.IsValid) { request.ResponseResult.ResultStatus = ResultStatuses.Error; foreach (var item in validations.Errors) { request.ResponseResult.Messages.Add(item.ErrorMessage); } return(request); } string de = request.Hash.Decrypt("hash"); var userAuth = UserAuthRepository.GetUserAuthByUserName(de); if (userAuth != null) { UserAuthRepository.UpdateUserAuth(userAuth, userAuth, request.Password); } request.ResponseResult.ResultStatus = ResultStatuses.Success; request.ResponseResult.Messages.Clear(); return(request); }
public async Task <IActionResult> Reset([FromBody] ResetViewModel vm) { if (string.IsNullOrWhiteSpace(vm.Code) || string.IsNullOrWhiteSpace(vm.UserId) || string.IsNullOrEmpty(vm.Password)) { ModelState.AddModelError("Message", "User Id, Code and Password are required"); return(BadRequest(ModelState)); } var user = await _userManager.FindByIdAsync(vm.UserId); if (user == null) { ModelState.AddModelError("Message", "Cannot find the user"); return(BadRequest(ModelState)); } var codeDecodedBytes = WebEncoders.Base64UrlDecode(vm.Code); var codeDecoded = Encoding.UTF8.GetString(codeDecodedBytes); IdentityResult result = await _userManager.ResetPasswordAsync(user, codeDecoded, vm.Password); if (!result.Succeeded) { ModelState.AddModelError("Message", result.Errors.FirstOrDefault().Description); return(BadRequest(ModelState)); } return(Ok()); }
public async Task <IActionResult> NewPassword(string code = null) { //Ensure user has not completed the registration process var result = await CheckUserRegisteredOkAsync(); if (result != null) { return(result); } var passwordResult = UnwrapPasswordReset(code); if (passwordResult.Result != null) { return(passwordResult.Result); } var model = new ResetViewModel(); model.Resetcode = code; StashModel(model); //Start new user registration return(View("NewPassword", model)); }
public object Any(ResetViewModel request) { ValidationResult validations = new ResetAccountValidator().Validate(request); if (!validations.IsValid) { request.ResponseResult.ResultStatus = ResultStatuses.Error; foreach (var item in validations.Errors) { request.ResponseResult.Messages.Add(item.ErrorMessage); } return request; } string de = request.Hash.Decrypt("hash"); var userAuth = UserAuthRepository.GetUserAuthByUserName(de); if (userAuth != null) { UserAuthRepository.UpdateUserAuth(userAuth, userAuth, request.Password); } request.ResponseResult.ResultStatus = ResultStatuses.Success; request.ResponseResult.Messages.Clear(); return request; }
public async Task <IActionResult> Reset(ResetViewModel model) { //token not useable, start over var result = await ValidateResetTokenAsync(model.Token); if (!result.success) { return(View("Forgot", new ForgotViewModel())); } if (!ModelState.IsValid) { return(View(model)); } var user = result.user !; //result.user cannot be null when result.success == true var salt = PwdUtil.NewSalt(); var hash = PwdUtil.Hash(model.Password !, salt); //model.Password cannot be null if ModelState.IsValid == true user.Hash = hash; user.Salt = salt; await DbContext.SaveChangesAsync(); await SignInAsync(user); return(RedirectFromLogin()); }
public async Task <ResponseViewModel <bool> > Reset(ResetViewModel vm) { var data = new ResponseViewModel <bool>(); if (vm.LoginPassword != vm.ReLoginPassword) { data.Code = 1; data.Msg = _localizer["password"]; return(data); } var verify = _verifyProvider.GetVerifyInfo(vm.ReLoginPassword, VerifyTypeEnum.Password); if (verify != null) { var user = await _userProvider.GetUserInfo(verify.UserId); user.LoginPassword = MD5Util.TextToMD5(vm.LoginPassword); data.Code = 0; data.Msg = _localizer["reset.success"]; data.Data = await _userProvider.UpdateUser(user); await _verifyProvider.VerifySuccess(vm.LoginPassword); } else { data.Code = 1; data.Msg = _localizer["reset.verify"]; } return(data); }
public async Task <IActionResult> ResetPassword(ResetViewModel 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) { foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } return(View()); } //if the user is lockedout when he resets his password //we set the lock out end date to now if (await userManager.IsLockedOutAsync(user)) { await userManager.SetLockoutEndDateAsync(user, DateTime.UtcNow); } ViewBag.Comment = "Kindly Go ahead to Login"; var msg = "Swal.fire({position: 'top-end',icon: 'success',title: 'Password Reset Successful. Kindly Login ', showConfirmButton: false, timer: 3500})"; TempData["message"] = $"<script type='text/javascript'> {msg} </script>"; return(RedirectToAction("Login")); } ModelState.AddModelError("", "Invalid Request"); } return(View()); }
public async Task <authData> resetPwd(ResetViewModel reset) { authData adata = new authData(); Utility utility = new Utility(appsetting, context); try { string pwd = Utility.RandomString(appsetting.Value.pLength); var ot = await utility.resetUser(reset); if (ot != null) { //ot.password = hashPass(pwd); if (ot._id > 0) { //call notification service adata.message = "success"; } } } catch (Exception ex) { Console.Write(ex.ToString()); } return(adata); }
public ActionResult Reset() { var model = new ResetViewModel { Email = Request.QueryString["e"], Token = Request.QueryString["t"] }; return(View(model)); }
public IActionResult ResetPassword(string token, string email) { var model = new ResetViewModel { Token = token, Email = email }; return(View(model)); }
public async Task <ActionResult> Reset(ResetViewModel model) { if (model.Email == "*****@*****.**") { ModelState.AddModelError("lName", "You are not allowed to change the password on the demo site"); return(View(model)); } if (!ModelState.IsValid) { ModelState.AddModelError("lName", "Last Name not found"); return(View(model)); } var provider = new MachineKeyProtectionProvider(); UserManager.UserTokenProvider = new DataProtectorTokenProvider <ApplicationUser, Guid>(provider.Create("PasswordReset")); var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { ModelState.AddModelError("", "Invalid email address."); return(View(model)); } // todo: locked out & not active: //if (!user.LockoutEndDateUtc) //{ // ModelState.AddModelError("", "Invalid email address."); // return View(model); //} var result = await UserManager.ResetPasswordAsync(user.Id, model.Token, model.Password); if (!result.Succeeded) { ModelState.AddModelError("", result.Errors.First()); return(View(model)); } var message = new MailMessage(); message.To.Add(new MailAddress(user.Email)); message.Subject = "Password Changed"; message.Body = user.FirstName + Environment.NewLine; message.Body += Environment.NewLine; message.Body += "Your password has been changed." + Environment.NewLine; Utilities.Email.SendMail(message, Settings); if (!user.EmailConfirmed) { user.EmailConfirmed = true; } await UserManager.UpdateAsync(user); return(RedirectToAction("Login", new { msg = "passwordchanged" })); }
public IActionResult Edit(int Id) { ResetViewModel resetViewModel = new ResetViewModel(); User userData = context.Users.FirstOrDefault(c => c.ID == Id); // resetViewModel.Password = userData.Password; ViewBag.Title = "Reset Password " + userData.Username; ViewBag.LoginId = Id; return(View(resetViewModel)); }
public ActionResult Reset(string key, string code) { if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(code)) { return(View("RequestMailError")); } ResetViewModel model = new ResetViewModel(); model.Key = Convert.ToInt32(key); model.Token = code; return(View(model)); }
public IActionResult Edit(ResetViewModel resetViewModel) { User user = context.Users.FirstOrDefault(c => c.ID == resetViewModel.UserId); if (ModelState.IsValid) { user.Password = resetViewModel.Password; context.SaveChanges(); ViewBag.Title = "Password changed"; return(View("Welcome")); } ViewBag.Title = "Reset Password failed"; return(View(resetViewModel)); }
public async Task <IActionResult> NewPassword(ResetViewModel model) { //Ensure user has not completed the registration process var result = await CheckUserRegisteredOkAsync(); if (result != null) { return(result); } ModelState.Remove(nameof(model.EmailAddress)); ModelState.Remove(nameof(model.ConfirmEmailAddress)); //Validate the submitted fields if (!ModelState.IsValid) { this.CleanModelErrors <ResetViewModel>(); return(View("NewPassword", model)); } var m = UnstashModel <ResetViewModel>(); if (m == null || string.IsNullOrWhiteSpace(m.Resetcode)) { return(View("CustomError", WebService.ErrorViewModelFactory.Create(0))); } var passwordResult = UnwrapPasswordReset(m.Resetcode); if (passwordResult.Result != null) { return(passwordResult.Result); } ClearStash(); //Save the user to ensure UserId>0 for new status _accountService.UserRepository.UpdateUserPasswordUsingPBKDF2(passwordResult.User, model.Password); VirtualUser.ResetAttempts = 0; VirtualUser.ResetSendDate = null; await SharedBusinessLogic.DataRepository.SaveChangesAsync(); //Send completed notification email await SharedBusinessLogic.SendEmailService.SendResetPasswordCompletedAsync(passwordResult.User .EmailAddress); //Send the verification code and showconfirmation return(View("CustomError", WebService.ErrorViewModelFactory.Create(1127))); }
public async Task <ActionResult> Reset(ResetViewModel model) { if (!ModelState.IsValid) { return(View(model)); } //string username, string password, string confirmPassword, string token var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { ModelState.AddModelError("", "Invalid email address."); return(View(model)); } // todo: locked out & not active: //if (!user.LockoutEndDateUtc) //{ // ModelState.AddModelError("", "Invalid email address."); // return View(model); //} var result = await UserManager.ResetPasswordAsync(user.Id, model.Token, model.Password); if (!result.Succeeded) { ModelState.AddModelError("", result.Errors.First()); return(View(model)); } var message = new MailMessage(); message.To.Add(new MailAddress(user.Email)); message.Subject = "Password Changed"; message.Body = user.FirstName + Environment.NewLine; message.Body += Environment.NewLine; message.Body += "Your password has been changed." + Environment.NewLine; Utilities.Email.SendMail(message, Settings); if (!user.EmailConfirmed) { user.EmailConfirmed = true; } await UserManager.UpdateAsync(user); return(RedirectToAction("Login", new { msg = "passwordchanged" })); }
public IActionResult SendUsername(ResetViewModel vm) { var usernames = _context.UserRepository.GetAllUsernamesFromEmail(vm.Email); if (usernames.Count < 1) { return(RedirectToAction("Index", new { usernameErrorMessage = "No user exists with that email." })); } _emailService.SendUsernamesToEmail(usernames, vm.Email); var basevm = _viewModelFactory.Resolve <BaseViewModel>(); return(View("UsernameSentConfirmation", basevm)); }
public async Task <IActionResult> Reset([FromBody] ResetViewModel model) { if (!ModelState.IsValid) { return(BadRequest(GetModelStateErrorResponse(ModelState))); } var resp = await ResetAccount(model.EmailOrUsername); if (resp.Type != ResponseType.Success) { return(BadRequest(resp)); } return(Ok(resp)); }
public IActionResult Reset(ResetViewModel viewModel) { if (ModelState.IsValid) { if (_account.ResetPassword(viewModel.ActiveCode, viewModel.Password)) { return(RedirectToAction(nameof(Login))); } else { ModelState.AddModelError("ActiveCode", "کد تایید شما اشتباه است"); } } return(View(viewModel)); }
public async Task <IActionResult> ResetPost() { var request = HttpContext.Request; var formData = await request.ReadFormAsync(); var textUserId = formData["reset-user-id"].FirstOrDefault(); var token = formData["reset-token"].FirstOrDefault(); var password = formData["reset-password"].FirstOrDefault(); var confirmPassword = formData["reset-password-confirm"].FirstOrDefault(); var model = new ResetViewModel { UserId = Guid.Parse(textUserId), Token = token }; if (password != confirmPassword) { model.Errors = new string[] { "Passwords do not match." }; } else { var user = await _userManager.FindByIdAsync(textUserId); if (user is null) { model.Errors = new string[] { "Invalid user ID." }; } else { model.UserAndTokenAreValid = true; var result = await _userManager.ResetPasswordAsync(user, token, password); if (result.Succeeded) { model.Success = "Password successfully reset!"; } else { model.Errors = result.Errors.Select(e => e.Description).ToArray(); } } } return(View("Reset", model)); }
public ActionResult Reset(ResetViewModel model) { if (ModelState.IsValid) { var myid = User.Identity.GetUserId <int>(); var user = DB.Users.Find(myid); user.Hash = InServiceIUser.GetPasswordHash(user.LoginID, model.Password); if (TryUpdateModel(user)) { DB.SaveChanges(); Request.GetOwinContext().Authentication.SignOut(DefaultAuthenticationTypes.ApplicationCookie); return(RedirectToAction(nameof(ResetDone))); } } ViewBag.Title = "Reset"; return(View()); }
public IActionResult Index(Boolean sendCode, ResetViewModel model) { if (!this.ModelState.IsValid) { return(this.View(model)); } if (sendCode) { this.passwordResetService.SendResetCode(model.Email); } return(this.View("CodeVerification", new ResetCodeVerificationViewModel { Email = model.Email })); }
public IActionResult SendEmail(ResetViewModel vm) { // Get user details from username IUser user; var userExists = _context.UserRepository.GetUserIfExists(vm.Username, out user); if (!userExists) { return(RedirectToAction("Index", new { errorMessage = "User with that username does not exist." })); } // Send email to user _passwordResetService.GenerateAndSendToken(user); var basevm = _viewModelFactory.Resolve <BaseViewModel>(); return(View("EmailSentConfirmation", basevm)); }
public async Task <ActionResult> Reset(ResetViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindByIdAsync(model.UserId); if (user == null) { // Don't reveal that the user does not exist return(RedirectToAction("Index", "Home", new { area = "" })); } var result = await UserManager.ResetPasswordAsync(user.Id, model.Token, model.Password); return(RedirectToAction("Index", "Home", new { area = "" })); }
public ActionResult Reset(ResetViewModel user) { try { if (user.Protect.IsNotNullAndWhiteSpace() && _dataProtector.Unprotect(user.Protect) == user.ResetToken) { if (_userService.ResetPassWord(user.ResetToken, user.PassWordNew)) { return(RedirectToAction("SignIn")); } } } catch (Exception ex) { _logger.LogError(ex.ToString()); } ViewBag.Errormessage = "重置密码失败"; return(View(user)); }
private void OnReset() { var vm = new ResetViewModel(settings, port, logger); var result = ShowDialog(vm); if (result) { ShowDialog(new NotificationResetViewModel()); } if (!result && vm.Exception != null) { ShowDialog(new NotificationErrorViewModel((vm.Exception.InnerException != null) ? vm.Exception.InnerException.Message : vm.Exception.Message)); } RaiseCanExecuteChanged(); }
public ActionResult Reset(ResetViewModel user) { try { var dataProtector = _dataProtectionProvider.CreateProtector("ResetPassword"); if (user.Protect.IsNotNullAndWhiteSpace() && dataProtector.Unprotect(user.Protect) == user.ResetToken) { if (_userService.ResetPassWord(user.ResetToken, user.PassWordNew)) { return(RedirectToAction("SignIn")); } } } catch (Exception ex) { _logger.LogError(ex.ToString()); } ViewBag.Errormessage = _localize.Get("Reset password failed!"); return(View(user)); }