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);
}
