public void ChangePassword() { //首先向数据库中添加一个用户 FrameworkUserBase v = new FrameworkUserBase(); using (var context = new DataContext(_seed, DBTypeEnum.Memory)) { v.ITCode = "user"; v.Name = "name"; v.Password = Utils.GetMD5String("password"); v.IsValid = true; context.Set <FrameworkUserBase>().Add(v); context.SaveChanges(); } //调用ChangePassword PartialViewResult rv = (PartialViewResult)_controller.ChangePassword(); //测试是否正确返回ChangePasswordVM Assert.IsInstanceOfType(rv.Model, typeof(ChangePasswordVM)); //使用返回的ChangePasswordVM,给字段赋值 ChangePasswordVM vm = rv.Model as ChangePasswordVM; vm.ITCode = "user"; vm.OldPassword = "******"; vm.NewPassword = "******"; vm.NewPasswordComfirm = "p1"; //调用ChangePassword方法修改密码 var rv2 = _controller.ChangePassword(vm); //测试是否正确修改了密码 using (var context = new DataContext(_seed, DBTypeEnum.Memory)) { var u = context.Set <FrameworkUserBase>().FirstOrDefault(); Assert.AreEqual(u.Password, Utils.GetMD5String("p1")); } //测试是否正确返回 Assert.IsInstanceOfType(rv2, typeof(FResult)); }
public async Task <IActionResult> ChangePassword(ChangePasswordVM m) { if (!ModelState.IsValid) { return(View()); } var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.")); } m.OldPassword = m.OldPassword.PersianToEnglish(); m.NewPassword = m.NewPassword.PersianToEnglish(); var changePasswordResult = await _userManager.ChangePasswordAsync(user, m.OldPassword, m.NewPassword); if (!changePasswordResult.Succeeded) { foreach (var error in changePasswordResult.Errors) { if (error.Code.Equals("PasswordRequiresLower")) { error.Description = "کلمه عبور باید حاوی یک حرف انگلیسی کوچک باشد ('a'-'z')"; } if (error.Code.Equals("PasswordRequiresDigit")) { error.Description = "کلمه عبور باید حاوی یک عدد باشد ('0'-'9')"; } ModelState.AddModelError(string.Empty, error.Description); } return(View()); } await _signInManager.RefreshSignInAsync(user); TempData["msg"] = "کلمه عبور شما با موفقیت تغییر یافت. |success"; return(View()); }
public ActionResult ChangePass(ChangePasswordVM model) { if (ModelState.IsValid) { var UserLogOn = LoginDao.UserLogOn(); if (UserLogOn.Password == model.OldPassword.GetMD5()) { UserLogOn.Password = model.NewPassword; var update = db.Users.Single(u => u.UserID == UserLogOn.UserID); update.Password = model.NewPassword.GetMD5(); db.SaveChanges(); ViewBag.Message = "Đổi mật khẩu thành công"; } else { ViewBag.Message = "Mật Khẩu cũ không đúng"; } return(View()); } return(View()); }
public ActionResult ChangePassword(ChangePasswordVM model) { if (ModelState.IsValid) { string userId = User.Identity.GetUserId <string>(); IdentityResult identityResult = userManager.ChangePassword(userId, model.CurrentPassword, model.NewPassword); if (!identityResult.Succeeded) { ModelState.AddModelError("", identityResult.Errors.First()); return(View(model)); } return(RedirectToAction("Index")); } else { return(View(model)); } }
public string ChangePassword(ChangePasswordVM model) { string userId = string.Empty; SqlParameter[] parameters = { new SqlParameter { ParameterName = "@Id", Value = model.UserId }, new SqlParameter { ParameterName = "@Password", Value = model.Password }, new SqlParameter { ParameterName = "@UpdatedBy", Value = model.UpdatedBy } }; userId = Convert.ToString(DALHelper.ExecuteScalar("ChangePassword", parameters)); return(userId); }
public async Task <IActionResult> ChangePassword(string id, ChangePasswordVM model) { if (id == null || model == null || !ModelState.IsValid) { return(NotFound()); } ApplicationUser user = await _userManager.FindByIdAsync(id); if (user == null) { return(NotFound()); } string token = await _userManager.GeneratePasswordResetTokenAsync(user); await _userManager.ResetPasswordAsync(user, token, model.ConfirmPassword); await _context.SaveChangesAsync(); ViewBag.IsHeaderNonVisible = true; return(PartialView("PasswordChanged")); }
public async Task <ActionResult> ChangePassword(ChangePasswordVM model) { if (!ModelState.IsValid) { return(View(model)); } var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId <long>(), model.OldPassword, model.NewPassword); if (result.Succeeded) { var user = await UserManager.FindByIdAsync(User.Identity.GetUserId <long>()); if (user != null) { await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false); } return(RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess })); } AddErrors(result); return(View(model)); }
public async Task <IActionResult> Changepassword(ChangePasswordVM vm) { User user = await userManager.FindByIdAsync(vm.UserId); if (!ModelState.IsValid) { return(View(vm)); } IdentityResult result = await userManager.ResetPasswordAsync(user, vm.Token, vm.Password); if (!result.Succeeded) { ModelState.AddModelError("", "The password does not meet requirements."); return(View(vm)); } await userManager.UpdateAsync(user); TempData["update"] = true; return(RedirectToAction(nameof(SignIn))); }
public async Task <IActionResult> ChangePassword(ChangePasswordVM changePassword) { if (!ModelState.IsValid) { return(View(changePassword)); } var user = await _dbContext.Users.SingleOrDefaultAsync(x => _userManager.FindByNameAsync(User.Identity.Name).GetAwaiter().GetResult().Id == x.Id); var email = user.Email; IdentityResult result = await _userManager.ChangePasswordAsync(user, changePassword.OldPassword, changePassword.Password); if (!result.Succeeded) { ModelState.AddModelError("", "Old password is wrong!!"); return(View(changePassword)); } return(RedirectToAction("Index", "Home")); }
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordVM model) { var userId = User?.FindFirstValue(ClaimTypes.NameIdentifier); var user = await _userManager.Users.FirstOrDefaultAsync(x => x.Id == userId); if (user == null) { throw new UserNotFoundException(userId); } var isRegisteredBefore = await _userManager.HasPasswordAsync(user); if (!isRegisteredBefore) { throw new UserNotRegisteredException(user.PhoneNumber); } if (!user.PhoneNumberConfirmed) { throw new PhoneNumberNotConfirmedException(user.PhoneNumber); } var results = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (!results.Succeeded) { var error = results.Errors.FirstOrDefault(); if (error != null) { throw new ChangePasswordException(error.Description, error.Code); } else { throw new ChangePasswordException("Error while changing password", "changing_password_error"); } } return(Ok()); }
public async Task <ActionResult <UserProfile> > ChangePassword([FromBody] ChangePasswordVM vM) { User user = await userManager.FindByEmailAsync(vM.Username); var _passwordValidator = HttpContext.RequestServices.GetService(typeof(IPasswordValidator <User>)) as IPasswordValidator <User>; var Hasher = HttpContext.RequestServices.GetService(typeof(IPasswordHasher <User>)) as IPasswordHasher <User>; User tempU = new User(); bool res = false; if (user != null) { res = await userManager.CheckPasswordAsync(user, vM.OldPassword); } if (res) { IdentityResult result = await _passwordValidator.ValidateAsync(userManager, user, vM.NewPassword); if (result.Succeeded) { user.PasswordHash = Hasher.HashPassword(user, vM.NewPassword); await userManager.UpdateAsync(user); return(Ok(true)); } else { return(Ok(false)); } } else { return(Ok(false)); } }
public ActionResult ChangePassword(ChangePasswordVM vm) { vm.Username = User.Identity.Name; if (!ModelState.IsValid) { return(View(vm)); } User user = UserService.GetUser(User.Identity.Name); if (!PasswordHash.ValidatePassword(vm.OldPassword, user.PasswordHash)) { ModelState.AddModelError(string.Empty, "The password you entered did not match. Please double-check and try again"); return(View(vm)); } user.Password = vm.Password; UserService.SaveUser(user); Info = "Change password successfully"; return(RedirectToAction("Index")); }
public async Task <IActionResult> ChangePassword() { var user = await _userManager.GetUserAsync(User); if (user == null) { throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); } var hasPassword = await _userManager.HasPasswordAsync(user); if (!hasPassword) { return(RedirectToAction(nameof(SetPassword))); } var model = new ChangePasswordVM { StatusMessage = StatusMessage }; return(View(model)); }
public async Task <string> ChangePassword(string id, ChangePasswordVM changePasswordVM) { var existUser = await _myContext.Users.Where(q => q.Id == id).FirstOrDefaultAsync(); var isValid = BCrypt.Net.BCrypt.Verify(changePasswordVM.OldPassword, existUser.PasswordHash); if (!isValid) { return("Old Passoword is wrong !"); } var hashedPassword = BCrypt.Net.BCrypt.HashPassword(changePasswordVM.NewPassword, 12); existUser.PasswordHash = hashedPassword; var result = await _myContext.SaveChangesAsync(); if (result == 0) { return("Server error !"); } return(null); }
public IActionResult ConfirmNewPassword(ChangePasswordVM model) { if (!ModelState.IsValid) { return(View("ChangePassword", model)); } string value = (string)TempData["value"]; ChangePasswordCode changepw = con.ChangePasswords.SingleOrDefault(i => i.Value == value); User user = con.Users.SingleOrDefault (i => i.Id == changepw.UserId); user.PasswordHash = HashHelper.GetHash(model.Password, Convert.FromBase64String(user.PasswordSalt)); con.ChangePasswords.Remove(changepw); con.SaveChanges(); TempData["successMessage"] = "Your password is successfully changed."; return(RedirectToAction("Index")); }
public ActionResult ChangePassword(ChangePasswordVM model) { User user = _mapper.Map <ChangePasswordVM, User>(model); if (ModelState.IsValid && _authService.ValidateUser(user)) { using (MD5 md5Hash = MD5.Create()) { user.Password = _cryptoHelper.GetMd5Hash(md5Hash, model.NewPassword); if (_userService.UpdatePassword(user)) { TempData["AlertMessage"] = AlertHelper.SuccessAlert("Success", "Your last action was successful."); return(RedirectToAction("Logout")); } } } TempData["AlertMessage"] = AlertHelper.DangerAlert("Unsuccessful", "You might have provided wrong data."); return(View(model)); }
public async Task <IActionResult> MailChangePassword(ChangePasswordVM model) { var user = _accountBusiness.GetUserByEmail(model.Email); if (user != null) { if (model.NewPassword == model.RepeatNewPassword) { Users selectedUser = _usersRepository.TableNoTracking.Where(i => i.Id == user.Id).FirstOrDefault(); selectedUser.IsFirstLogin = false; selectedUser.Password = _encryptionService.Encrypt(model.NewPassword); _usersRepository.Update(selectedUser); _uow.SaveChanges(); } else { ModelState.AddModelError("Email", LocalizationCaptions.EmailExists); return(View(model)); } } return(View(model)); }
public async Task <IActionResult> ChangePassword(ChangePasswordVM model) { if (!ModelState.IsValid) { return(View(model)); } if (ModelState.IsValid) { var user = await _userManager.FindByIdAsync(model.Id); // ChangePasswordAsync changes the user password var result = await _userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword); // The new password did not meet the complexity rules or // the current password is incorrect. Add these errors to // the ModelState and rerender ChangePassword view if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); model.ErroMessage = error.Description; } return(View("ChangePassword", model)); } // Upon successfully changing the password refresh sign-in cookie await _signInManager.RefreshSignInAsync(user); return(View("ChangePasswordConfrimation")); } return(View(model)); }
public async Task <IActionResult> ChangePassword(ChangePasswordVM model) { var user = await userManager.FindByIdAsync(model.Id); if (!ModelState.IsValid) { ModelState.AddModelError("", "Please fill all fields"); return(View(model)); } else { var result = await userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword); if (!result.Succeeded) { ModelState.AddModelError("", "Please enter the correct current password and the new password must contain " + "an uppercase letter, lower case letters, a number and a special character"); return(View(model)); } return(RedirectToAction("index")); } }
public async Task <IActionResult> ChangePassword(ChangePasswordVM vm) { if (!ModelState.IsValid) { return(View(vm)); } User u = GetUser(); if (!u.Password.Validate(vm.OldPassword)) { ModelState.AddModelError(nameof(vm.OldPassword), "That wasn't your old password"); return(View(vm)); } // At this point we know that the old password is right, // the new password is >= 12 chars, and the new and confirm // passwords match. So, change the password await lists.ChangePassword(u, vm.NewPassword); Message("Your password has been changed"); return(RedirectToRoute(Names.ListIndex, Names.ListHash)); }
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordVM model) { if (!ModelState.IsValid) { string errorMsg = null; foreach (var m in ModelState.Values) { foreach (var msg in m.Errors) { errorMsg = msg.ErrorMessage; } } return(BadRequest(errorMsg)); } var user = await _userManager.FindByIdAsync(User.Identity.Name); if (user != null) { var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { return(new NoContentResult()); } else { string errorMsg = null; foreach (var e in result.Errors) { errorMsg = e.Code; } return(new BadRequestObjectResult(errorMsg)); } } return(NotFound()); }
public async Task <IActionResult> ChangePassword(ChangePasswordVM changePasswordVM) { if (!ModelState.IsValid) { return(View(changePasswordVM)); } string activeUserName = User.Identity.Name; CustomUser customUserFromDb = await _userManager.FindByNameAsync(activeUserName); IdentityResult result = await _userManager.ChangePasswordAsync(customUserFromDb, changePasswordVM.CurrentPassword, changePasswordVM.NewPassword); await _userManager.UpdateAsync(customUserFromDb); if (!result.Succeeded) { ModelState.AddModelError("", "Hazırki şifrə yanlışdır və ya yeni şifrə tələblərə uyğun deyil."); return(View(changePasswordVM)); } TempData["PasswordChanged"] = true; return(RedirectToAction("List", "Employee")); }
public TransactionResult <object> BL_ChangePassword(ChangePasswordVM p_Obj, string p_Email) { MST_UserInfo UserObj = new DAL_User().DAL_GetUserValidity(p_Email).Data; if (new MD5Hashing().GetMd5Hash(p_Obj.OldPassword).Equals(UserObj.Password)) { bool result = new DAL_User().DAL_SaveNewPassword(UserObj.Email, new MD5Hashing().GetMd5Hash(p_Obj.NewPassword)); return(new TransactionResult <object> { Success = true, RedirectURL = "/Notes/List", Message = "Password Successfully updated" }); } else { return(new TransactionResult <object> { Success = false, Message = "Incorrect Old Password" }); } }
public ActionResult ChangePassword(ChangePasswordVM entity) { if (ModelState.IsValid) { bool blnValidUser = PresentationLayer.Other.CommanMethods.GetValidUser(entity.UserId, entity.OldPassword); if (!blnValidUser) { ViewBag.Error = myRes.TheProvidedUserNameOrPasswordIsIncorrect; entity.UserList = PresentationLayer.Other.CommanMethods.GetUserList(); return(View(entity)); } UserBAL userBAL = new UserBAL(); Entities.User user = new Entities.User(); user.UserId = entity.UserId; user.Password = entity.NewPassword; userBAL.ChangePassword(user); ViewBag.Error = myRes.Passwordchangedsuccessfully; //return RedirectToAction("Index"); } entity.UserList = PresentationLayer.Other.CommanMethods.GetUserList(); return(View(entity)); }
public ActionResult ChangePassword() { Stream stream = Request.Body; ChangePasswordVM changeable = this.ReadRequestBody <ChangePasswordVM>(stream); User user = _UserRepo.GetUserByUsername(changeable.Username); bool isSame = PasswordOperator.ValidateMe(user.Password, changeable.NewPassword); bool isValid = PasswordOperator.ValidateMe(user.Password, changeable.OldPassword); if (isSame || !isValid) { return(StatusCode(417)); } else { string hashedPassword = PasswordOperator.HashMe(changeable.NewPassword); user.Password = hashedPassword; _UserRepo.UpdateEntityById(user); return(Ok()); } }
public async Task <ActionResult> ChangePassword(ChangePasswordVM changePasswordVM) { if (!ModelState.IsValid) { return(View(changePasswordVM)); } string userName = ""; var user = await _userService.FindAsync(userName, changePasswordVM.Password); if (user != null) { var passwordHash = new Microsoft.AspNet.Identity.PasswordHasher(); var hashedPassword = passwordHash.HashPassword(changePasswordVM.Password); user.PasswordHash = hashedPassword; await _userService.UpdateAsync(user, string.Empty); return(RedirectToAction("Index", "Home")); } ModelState.AddModelError("errormessage", "Current entered password is invalid"); return(View(changePasswordVM)); }
public ActionResult ChangePassword(ChangePasswordVM model) { var message = ""; if (ModelState.IsValid) { var currentUserId = (Membership.GetUser(User.Identity.Name) as CustomMembershipUser).UserId; using (RecruiterContext dbContext = new RecruiterContext()) { var User = dbContext.Users.Where(a => a.Id == currentUserId).FirstOrDefault(); if (User != null) { if (model.OldPassword != model.NewPassword) { User.Password = model.NewPassword; message = "Your password has been updated!"; dbContext.SaveChanges(); } else { message = "New password is the same as current password"; } } else { ModelState.AddModelError("Warning Error", "Information is not correct"); } } } ViewBag.Message = message; return(View(model)); }
public async Task <ActionResult> ChangePassword([FromBody] ChangePasswordVM model) { // This is called when the user presses the confirm email link that is sent to his/her inbox if (!ModelState.IsValid) { return(BadRequest("There is something wrong with the request payload")); // TODO: Return friendlier validation errors } try { // Get the user var username = User.UserName(); var user = await _userManager.FindByNameAsync(username); if (user == null) { // This is only possible if the admin deletes the user while the user is logged in return(BadRequest("Your account was deleted")); } // Rely on the injected user manager to validate the token and confirm the user's email IdentityResult result = await _userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword); if (!result.Succeeded) { return(BadRequest(result.ErrorMessage("Could not change password"))); } // All good return(Ok()); } catch (Exception ex) { _logger.LogError(ex.StackTrace); return(BadRequest(ex.Message)); } }
public async Task <Tuple <string, bool> > ChangePassword(string url, ChangePasswordVM passwordVM, string token) { var request = new HttpRequestMessage(HttpMethod.Patch, url + "changepassword/"); var client = _clientFactory.CreateClient(); if (token != null && token.Length > 0) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token); } request.Content = new StringContent(JsonConvert.SerializeObject(passwordVM), Encoding.UTF8, "application/json"); HttpResponseMessage response = await client.SendAsync(request); if (response.StatusCode == HttpStatusCode.NoContent) { return(Tuple.Create("", true)); } var jsonString = await response.Content.ReadAsStringAsync(); return(Tuple.Create(ModelStateDeserializer.DeserializeModelState(jsonString), false)); }
public async Task <bool> UpdateLoginPassword(ChangePasswordVM changePasswordVM) { var modelToBeUpdated = GetUserLoginDetails(changePasswordVM.UserId).Result; if (modelToBeUpdated.PasswordChangeCode == changePasswordVM.Code) { modelToBeUpdated.Password = changePasswordVM.Password; _context.Entry(modelToBeUpdated).State = EntityState.Modified; try { var response = await _context.SaveChangesAsync(); return(response >= 1); } catch (DbUpdateException ex) { throw new DbUpdateException(ex.Message); } } else { throw new Exception("Incorrect Code"); } }
public async Task<IdentityResult> ChangePasswordAsync(ChangePasswordVM model,string userId) { var result = await _users.ChangePasswordAsync(userId, model.OldPassword, model.NewPassword); if (result.Succeeded) { _loggingService.Info(string.Format("用户 {0} 修改了密码", Site.CurrentUserName)); } else { _loggingService.Error(string.Format("用户 {0} 修改密码失败", Site.CurrentUserName)); } return result; }
public async Task<ActionResult> ChangePassword(ChangePasswordVM model) { if (!ModelState.IsValid) { return View(model); } var result = await _userService.ChangePasswordAsync(model, User.Identity.GetUserId()); if (result.Succeeded) { var user = await _userService.FindByIdAsync(User.Identity.GetUserId()); if (user != null) { await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); } ViewBag.StatusMessage = "密码修改成功"; } AddErrors(result); return View(model); }