public ActionResult EditPassword(ChangePassViewModel model)
{
Client currentUser = this.GetLoggedUser();
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Por favor, complete todos campos");
}
else if (!model.Password.Equals(model.PasswordCheck))
{
ModelState.AddModelError("PasswordCheck", "Las contraseñas no coinciden");
}
else if (!PasswordUtilities.Compare(model.OldPassword, currentUser.Password, currentUser.PasswordSalt))
{
ModelState.AddModelError("OldPassword", "La contraseña actual es incorrecta");
}
else //ModelState.IsValid && model.Password.Equals(model.PasswordCheck) both true
{
currentUser.Password = model.Password;
clientRepository.HashPassword(currentUser);
clientRepository.UpdateClient(currentUser);
clientRepository.Save();
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IHttpActionResult> ChangePassword([FromBody] ChangePassViewModel changePassViewModel)
{
if (User.Identity.GetUserId() == null)
{
return(this.Unauthorized());
}
DTOUser user = new DTOUser()
{
Login = User.Identity.GetUserName(), Password = changePassViewModel.OldPassword
};
if (!await _uow.UserManagerService.CheckUserByLoginPas(user))
{
return(BadRequest("Validation failed."));
}
if (changePassViewModel.ConfirmPassword != changePassViewModel.NewPassword)
{
ModelState.AddModelError("passwords", "Passwords are not equal");
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
await _uow.UserManagerService.ChangePassword(User.Identity.GetUserId <int>(), changePassViewModel.OldPassword, changePassViewModel.NewPassword);
return(Ok("Password has been updated."));
}
public async Task <IActionResult> ChangePassword(ChangePassViewModel vm)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
if (vm.Id != user.Id)
{
return(Unauthorized("Incorrect user"));
}
var changePasswordResult =
await _userManager.ChangePasswordAsync(user, vm.OldPassword, vm.NewPassword);
if (changePasswordResult.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in changePasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(vm));
}
}
public ActionResult ChangePassword(ChangePassViewModel vo)
{
if (!ModelState.IsValid)
{
return(View(vo));
}
if (vo.Id != CurrentUser.CustomerId)
{
ModelState.AddModelError("", "无权操作！");
return(View(vo));
}
var entity = _customerRepository.Find(vo.Id);
if (!SecurityHelper.CheckEqual(vo.Password, entity.Password))
{
ModelState.AddModelError("", "密码错误！");
return(View(vo));
}
entity.Password = SecurityHelper.ComputeHash(vo.NewPassword);
entity.UpdatedDate = DateTime.Now;
entity.UpdatedUser = CurrentUser.CustomerId;
_customerRepository.Update(entity);
ViewBag.IsUpdateSuccess = true;
return(View());
}
public async Task <ActionResult> ChangePassword(ChangePassViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var id = Guid.Parse(Session["UserId"].ToString());
var user = await _db.Users.FindAsync(id);
if (user == null)
{
return(HttpNotFound());
}
if (!EncryptDecrypt.CompareTwoMd5String(model.CurrentPassword, user.Password))
{
ModelState.AddModelError("", "Mật khẩu hiện tại không đúng");
return(View(model));
}
user.Password = EncryptDecrypt.GetMd5(model.NewPassword);
_db.Entry(user).State = EntityState.Modified;
await _db.SaveChangesAsync();
ViewData["message"] = "Thay đổi mật khẩu thành công!";
return(View());
}
public async Task <IActionResult> ChangePassword(ChangePassViewModel model)
{
// get name of user
string UserId = _ius.GetId();
ViewBag.fullname = _ius.GetById(UserId).FirstName + " " + _ius.GetById(UserId).LastName;
// update wallet
ViewBag.Wallet = _ius.GetById(UserId).Wallet;
if (ModelState.IsValid)
{
ApplicationUser user = new ApplicationUser();
var userId = _ius.GetId();
user = _ius.GetById(userId);
if (await _ius.CheckPasswordAsync(user, model.OldPassword))
{
// old password is Corrent
await _ius.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
ViewBag.changepass = "******";
return(View(model));
}
else
{
// old password is inCorrect
ModelState.AddModelError("", "رمز عبور قدیمی صحیح نیست");
ViewBag.wrongpass = "******";
return(View(model));
}
}
return(View(model));
}
public ActionResult PasswordChange([Bind(Include = "OldPassword,NewPassword,ConfirmNewPassword")] ChangePassViewModel passdata)
{
if (Session["User"] != null && Session["isAdmin"].Equals(false))
{
if (((User)Session["User"]).Password.Equals(Hash(passdata.OldPassword)))
{
var user = dbcontext.User.Find(((User)Session["User"]).Id);
user.Password = Hash(passdata.NewPassword);
((User)Session["User"]).Password = user.Password;
dbcontext.SaveChanges();
log.Info("Password Changed User : "******"Index", "Home"));
}
else
{
log.Info("Password Changed User Failed : " + ((User)Session["User"]).Id);
ViewBag.ErrorMessage = "The password you have entered is invalid.";
return(View());
}
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
public async Task <IActionResult> ChangeUserPass(string id, ChangePassViewModel model, string redirecturl)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(RedirectToAction("Index"));
}
var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
TempData["Notif"] = Notification.ShowNotif("خطایی رخ داد.", ToastType.red);
return(View());
}
//await _signInManager.RefreshSignInAsync(user);
TempData["Notif"] = Notification.ShowNotif("رمز عبور شما با موفقیت ویرایش شد.", ToastType.green);
return(PartialView("_Succefullyresponse", redirecturl));
}
return(View());
}
public ActionResult ChangePass()
{
try
{
// get currnet login user info
var userLogin = db.Users.Where(u => u.UserId == User.UserId).FirstOrDefault();
if (userLogin == null)
{
string errorMsg = string.Format("Tài khoản {0} không tồn tại!", User.UserId);
return(RedirectToAction("Message", "Error", new RouteValueDictionary(new { message = errorMsg })));
}
ChangePassViewModel model = new ChangePassViewModel();
model.UserId = userLogin.UserId;
model.Username = userLogin.Username;
model.FirstName = userLogin.FirstName;
model.LastName = userLogin.LastName;
model.Email = userLogin.Email;
return(View(model));
}
catch (Exception ex)
{
return(RedirectToAction("Message", "Error",
new RouteValueDictionary(new { message = ex.Message })));
}
}
public ActionResult ChangePass(ChangePassViewModel model)
{
try
{
if (ModelState.IsValid)
{
// get current user info
var userInfo = db.Users.Where(u => u.UserId == model.UserId).FirstOrDefault();
if (userInfo == null)
{
return(RedirectToAction("Login", "Auth"));
}
// verify old password
var isCorrectOldPass = SaltedHash.Verify(userInfo.Salt, userInfo.Password, model.OldPassword);
if (isCorrectOldPass)
{
// new password must be different to old passowrd
if (String.Compare(userInfo.Password, SaltedHash.ComputeHash(userInfo.Salt, model.NewPassword), false) != 0)
{
// update new user password
SaltedHash sh = new SaltedHash(model.NewPassword);
userInfo.Salt = sh.Salt;
userInfo.Password = sh.Hash;
userInfo.FirstName = model.FirstName;
userInfo.LastName = model.LastName;
userInfo.Email = model.Email;
db.SaveChanges();
// write action log
string actionLogData = "username="******"REMOTE_ADDR"]);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Mật khẩu mới không được trùng mật khẩu cũ");
}
}
else
{
ModelState.AddModelError("", "Mật khẩu cũ chưa chính xác");
}
}
else
{
ModelState.AddModelError("", "Thông tin đổi mật khẩu không hợp lệ!");
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
return(View(model));
}
public ActionResult ChangePassword(string id)
{
ChangePassViewModel model = new ChangePassViewModel()
{
Id = id
};
return(View(model));
}
/// <summary>
/// check password compare current password
/// </summary>
/// <param name="passModel"></param>
/// <returns></returns>
public bool CheckPass(ChangePassViewModel passModel)
{
var user = _unitofWork.UserBaseService.Get(s => s.Username == passModel.UserName);
if (user != null && user.Password != passModel.CurrentPass)
{
return(false);
}
return(true);
}
public async Task <IActionResult> ChangePassword()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var vm = new ChangePassViewModel()
{
Id = user.Id,
};
return(View(vm));
}
public async Task <IActionResult> ChangePassword([FromBody] ChangePassViewModel userForm)
{
try
{
await service.ChangePassword(userForm);
return(Ok());
}
catch (UserException ex)
{
return(BadRequest(ex));
}
}
/// <summary>
/// change password
/// </summary>
/// <param name="passModel"></param>
/// <returns></returns>
public bool ChangePass(ChangePassViewModel passModel)
{
var user = _unitofWork.DataContext.Users.Include(s => s.Role)
.FirstOrDefault(s => s.Username == passModel.UserName);
if (user == null)
{
return(false);
}
user.Password = passModel.Password;
_unitofWork.UserBaseService.Update(user);
_unitofWork.Save();
return(true);
}
public ActionResult ChangeUserPassword(ChangePassViewModel pModel)
{
try
{
if (ModelState.IsValid)
{
int?userID = (int?)Session["UserID"];
if (userID == null)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content("شما مجوز این کار را ندارید", System.Net.Mime.MediaTypeNames.Text.Plain));
}
User user = unitOfWork.UserRepository.GetByID(userID);
if (user == null)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content("رکورد مورد نظر یافت نشد", System.Net.Mime.MediaTypeNames.Text.Plain));
}
string oldPass = Hash(pModel.OldPassword);
//بررسی درست وارد شدن رمز عبور فعلی
if (oldPass != user.Password)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content("رمز عبور فعلی را اشتباه وارد کردید", System.Net.Mime.MediaTypeNames.Text.Plain));
}
string newHashPassword = Hash(pModel.NewPassword);
user.Password = newHashPassword;
unitOfWork.Save();
return(Json(true, JsonRequestBehavior.AllowGet));
}
else
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content("اطلاعات وارد شده نا معتبر است", System.Net.Mime.MediaTypeNames.Text.Plain));
}
}
catch (Exception ex)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content("خطایی در سیستم رخ داده است", System.Net.Mime.MediaTypeNames.Text.Plain));
}
}
public ActionResult EditPassword()
{
Client currentUser = this.GetLoggedUser();
if (currentUser != null)
{
ChangePassViewModel model = new ChangePassViewModel();
return(View(model));
}
else
{
return(RedirectToAction("Index", "Error", null));
}
}
public ActionResult ChangePassword()
{
if (CurrentUser.CustomerId == 0)
{
ModelState.AddModelError("", "参数验证失败.");
return(View());
}
var vo = new ChangePassViewModel()
{
Id = CurrentUser.CustomerId
};
return(View(vo));
}
public async Task <IActionResult> ChangePassword(string id)
{
User user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
ChangePassViewModel model = new ChangePassViewModel {
Id = user.Id, Email = user.Email
};
return(View(model));
}
public async Task <IActionResult> ChangePassword([FromBody] ChangePassViewModel model)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var changePasswordResult = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (!changePasswordResult.Succeeded)
{
return(BadRequest());
}
return(Ok());
}
public async Task ChangePassword(ChangePassViewModel userForm)
{
if (userForm.NewPassword != userForm.ConfirmNewPassword)
{
throw new UserException("Senhas não conferem");
}
var user = await userManager.FindByEmailAsync(userForm.Email);
var changePass = userManager.ChangePasswordAsync(user, userForm.OldPassword, userForm.NewPassword);
if (!changePass.Result.Succeeded)
{
throw new UserException(changePass.Result.Errors);
}
}
public IActionResult ChangePassword(ChangePassViewModel myAccountVM)
{
UserProfile userProfile = _userProfileDatabase.Find(s => s.UserName == User.Identity.Name && s.IsDeleted == false).FirstOrDefault();
if (myAccountVM.OldPassword != userProfile.Password)
{
return(RedirectToAction("MyAccount", "Account", new { mess = "Wrong Old Password" }));
}
else
{
userProfile.Password = myAccountVM.NewPassword;
_userProfileDatabase.Update(userProfile);
}
return(RedirectToAction("ProductView", "Product"));
}
public IActionResult ChangePass(ChangePassViewModel passDto)
{
if (ModelState.IsValid)
{
if (!_account.CheckPass(passDto))
{
ModelState.AddModelError("", MessageResource.InvalidCredentials);
return(View(passDto));
}
if (_account.ChangePass(passDto))
{
return(RedirectToAction("LogIn", "Account"));
}
}
ModelState.AddModelError("", MessageResource.ChangePassFailed);
return(View(passDto));
}
public ActionResult ChangePass(ChangePassViewModel model)
{
if (ModelState.IsValid)
{
if (model.oldpassword == model.password)
{
ViewBag.anno = "Mật khẩu mới không được trùng mật khẩu cũ !";
return(View());
}
else
{
User user = db.UserRepository.FindByID((int)Session["UserID"]);
user.Password = Common.CalculateMD5Hash(model.password);
db.SaveChanges();
return(RedirectToAction("Logout"));
}
}
return(View());
}
public ActionResult ChangePass(ChangePassViewModel changepass)
{
var user = _storeContext.Users.Where(x => x.Username == changepass.Username).FirstOrDefault();
if (user == null)
{
ModelState.AddModelError("", "Incorrect Username");
return View();
}
var passw = Generatehash(changepass.CurrentPassword + hashstr);
if (user.Password == passw && changepass.NewPassword.Length > 7 && changepass.NewPassword == changepass.ConfirmnewPassword)
{
user.Password = Generatehash(changepass.NewPassword + hashstr);
_storeContext.SaveChanges();
Session["User"] = null;
return View("Chngpass");
}
ModelState.AddModelError("", "Incorrect Username or Password");
return View();
}
public ActionResult ChangePass(ChangePassViewModel vm)
{
if (ModelState.IsValid)
{
var user = this._userService.GetUser((HttpContext.User as UserPrincipal).Id);
if (user.Password != vm.OldPassword)
{
ViewBag.ErrorSavingMessage = true;
return(this.View());
}
user.Password = user.PasswordConfirm = vm.NewPassword;
this._userService.SaveUser();
ViewBag.SavedSuccessfullyMessage = true;
return(this.View());
}
return(this.View());
}
public ActionResult ChangePassword(ChangePassViewModel model)
{
if (ModelState.IsValid)
{
var removePassword = UserManager.RemovePassword(model.Id);
if (removePassword.Succeeded)
{
var AddPassword = UserManager.AddPassword(model.Id, model.Password);
if (AddPassword.Succeeded)
{
return(RedirectToAction("Index", "UsersAndGroups"));
}
else
{
ModelState.AddModelError("", "Недопустимый пароль!");
}
}
}
return(View(model));
}
public async Task <IActionResult> ChangePass(ChangePassViewModel model)
{
ApplicationUser user = await userManager.FindByNameAsync(model.EmailAddress);
if (user == null)
{
TempData["GlobalError"] = "User doesn't exist.";
return(RedirectToAction("Index"));
}
user.PasswordHash = userManager.PasswordHasher.HashPassword(user, model.NewPass);
var result = await userManager.UpdateAsync(user);
if (!result.Succeeded)
{
TempData["GlobalError"] = $"Changing password was Unsuccessful. {result.Errors.ToString()}";
return(RedirectToAction("Index"));
}
TempData["GlobalSuccess"] = "Password changed Successfully.";
return(RedirectToAction("Index"));
}
/// <summary>
/// change password
/// </summary>
/// <param name="passModel"></param>
/// <returns></returns>
public bool ChangePass(ChangePassViewModel passModel)
{
var user = _unitofWork.UserBaseService.ObjectContext.Include(s => s.Role)
.FirstOrDefault(s => s.Username == passModel.UserName);
if (user == null)
{
return(false);
}
var userUpdate = new User
{
Username = user.Username,
Id = user.Id,
Password = passModel.Password,
RoleId = user.Id
};
_unitofWork.UserBaseService.Update(userUpdate);
_unitofWork.Save();
return(true);
}
public async Task <IActionResult> ChangePassword(ChangePassViewModel model)
{
if (ModelState.IsValid)
{
User user = await _userManager.FindByIdAsync(model.Id);
if (user != null)
{
var _passwordValidator =
HttpContext.RequestServices.GetService(typeof(IPasswordValidator <User>)) as
IPasswordValidator <User>;
var _passwordHasher =
HttpContext.RequestServices.GetService(typeof(IPasswordHasher <User>)) as IPasswordHasher <User>;
IdentityResult result =
await _passwordValidator.ValidateAsync(_userManager, user, model.NewPassword);
if (result.Succeeded)
{
user.PasswordHash = _passwordHasher.HashPassword(user, model.NewPassword);
await _userManager.UpdateAsync(user);
return(RedirectToAction("Index"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Пользователь не найден");
}
}
return(View(model));
}
