public async Task PostChangePassword_ReturnViewResult()
{
var user = new UserChangePasswordViewModel();
var result = await _userController.ChangePassword(user);
Assert.IsType <PartialViewResult>(result);
}
public ActionResult EditPassword(string uuid)
{
var user = _userService.FindBy(e => e.Uuid == uuid).FirstOrDefault();
if (user == null)
{
string message = Resources.ErrorMessages.UserNotAvailable;
if (Request.IsAjaxRequest())
{
return(JsonStatusGone(message));
}
else
{
AddViewMessage(TypeMessageView.ERROR, message);
return(RedirectToAction("Index"));
}
}
UserChangePasswordViewModel model = new UserChangePasswordViewModel {
Uuid = uuid,
Password = null,
ConfirmPassword = null
};
if (Request.IsAjaxRequest())
{
return(PartialView(model));
}
return(View(model));
}
public ActionResult ChangePassword(UserChangePasswordViewModel objEntity)
{
int result = 0;
UserRepository objUserRepository = new UserRepository();
if (ModelState.IsValid)
{
objEntity.NewPassword = objEntity.NewPassword.Trim();
objEntity.OldPassword = objEntity.OldPassword.Trim();
objEntity.UserEmail = SessionWrapper.UserAccount.UserEmail;
result = ValidateUserChangePassword(objEntity);
if (result == ResultFlags.Success.GetHashCode())
{
this.Flash("Success", "Password updated successfully");
AccountRepository.Logout();
return(RedirectToAction("Login", "User"));
}
else if (result == ResultFlags.Failure.GetHashCode())
{
this.Flash("Error", "Password failed to update");
}
else if (result == ResultFlags.OldPasswordMismatch.GetHashCode())
{
this.Flash("Warning", "Old password and new password cannot be same");
}
}
return(View(objEntity));
}
public async Task ChangePasswordAsync_UserNUll_ReturnFalse()
{
var user = new UserChangePasswordViewModel();
var result = await _userService.ChangePasswordAsync(user);
Assert.False(result);
}
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model)
{
var user = await _userManager.FindByNameAsync(HttpContext.User.Identity.Name);
var hasPassword = await _userManager.HasPasswordAsync(user);
if (!hasPassword)
{
ModelState.AddModelError("", "Пж, при сторонней авторизации пороль не нужен");
return(RedirectToAction("Profile", "Account"));
}
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "Неверные вводы");
return(View());
}
var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("ChangePasswordConfirmation", "Account"));
}
ModelState.AddModelError("", "Опрокидень смены пароля");
return(View());
}
public async Task <IActionResult> ChangePasswordCurUser(UserChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
User user = await _userManager.FindByIdAsync(model.Id);
if (user != null)
{
IdentityResult result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
else
{
ModelState.AddModelError(string.Empty, "User not found");
}
}
return(View(model));
}
public virtual async Task <ActionResult> ChangePassword(UserChangePasswordViewModel viewModel)
{
// Check
if (viewModel == null)
{
return(View(MVC.Error.Views.BadRequest));
}
// Validation
if (!ModelState.IsValid)
{
return(View(MVC.User.Views.ChangePassword, viewModel));
}
// Result
var result = await _userService.ChangePasswordAsync(Guid.Parse(User.Identity.GetUserId()), viewModel.OldPassword, viewModel.NewPassword);
if (result.Succeeded)
{
var user = await _userService.FindByIdAsync(Guid.Parse(User.Identity.GetUserId()));
await _signInManagerService.SignInAsync(user, false, false);
return(RedirectToAction(MVC.Account.SignOut()));
}
return(View(MVC.User.Views.ChangePassword, viewModel));
}
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(model.Id);
if (user == null)
{
return(NotFound());
}
await _userManager.RemovePasswordAsync(user);
await _userManager.AddPasswordAsync(user, model.Password);
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
AddErrors(result);
}
}
return(View(model));
}
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model)
{
if (!HasPermission("CHANGE_USERS_PASSWORDS"))
{
return(Unauthorized());
}
if (ModelState.IsValid)
{
var user = await _userManager.Users.FirstOrDefaultAsync(u => u.Id == model.Id);
if (user == null)
{
return(NotFound());
}
await _userManager.RemovePasswordAsync(user);
await _userManager.AddPasswordAsync(user, model.Password);
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
AddErrors(result);
}
}
return(View(model));
}
public async Task <IActionResult> EditPassword(UserChangePasswordViewModel vm)
{
if (vm.newPassword != vm.conPassword)
{
TempData.AddResult(SweetAlertExtenstion.Error("NewPassword and Confirm not equal"));
return(RedirectToAction("Index"));
}
var user = await _userRepository.GetByIdAsync(this.UserId);
//if (user.PasswordHash == vm.oldPassword)
//{
var newVm = new AdminSetPasswordViewModel
{
UserId = this.UserId,
Password = vm.Password
};
var sweetMessage = await _userRepository.AdminChangePassword(newVm);
TempData.AddResult(sweetMessage);
//}
//else
//{
// TempData.AddResult(SweetAlertExtenstion.Error("Old Password is incorect"));
//}
return(RedirectToAction("Profile"));
}
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await repository.UserManager.FindByIdAsync(model.Id);
if (user != null)
{
if (!await repository.UserManager.CheckPasswordAsync(user, model.ConfirmPassword))
{
ModelState.AddModelError(string.Empty, "Password is not correct");
return(View(model));
}
var result = await repository.UserManager.ResetPasswordAsync(
user,
await repository.UserManager.GeneratePasswordResetTokenAsync(user),
model.NewPassword);
if (result.Succeeded)
{
ModelState.AddModelError(string.Empty, "Your password has been changed");
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
}
return(View(model));
}
/// <summary>
/// Executa a troca de senha do usuário autenticado.
/// </summary>
/// <param name="userChange"></param>
/// <returns></returns>
public async Task <UserChangePasswordOutViewModel> ChangePassword(UserChangePasswordViewModel userChange)
{
if (userChange.CurrentPassword == userChange.NewPassword)
{
return new UserChangePasswordOutViewModel()
{
Code = 204, Description = "New password should be different than current password."
}
}
;
var mail = _authenticatedUser.GetEmail();
var user = await _userManager.FindByEmailAsync(mail);
var result = await _userManager.ChangePasswordAsync(user, userChange.CurrentPassword, userChange.NewPassword);
if (!result.Succeeded)
{
return new UserChangePasswordOutViewModel()
{
Code = 204, Description = "Could not change password."
}
}
;
return(new UserChangePasswordOutViewModel()
{
Code = 200, Description = "New password registered."
});
}
public async Task <ActionResult> ChangePassword(UserChangePasswordViewModel model)
{
if (!ModelState.IsValid)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(PartialView(model));
}
if (model.NewPassword != model.NewPasswordCopy)
{
ModelState.AddModelError("", "The new password and confirmation password does not match.");
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(PartialView(model));
}
AppUser user = GetCurrentUser();
bool correctPass = await _userManager.CheckPasswordAsync(user, model.OldPassword);
if (!correctPass)
{
ModelState.AddModelError("", "Please enter valid current password.");
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(PartialView(model));
}
IdentityResult validPass = await _userManager.PasswordValidator.ValidateAsync(model.NewPassword);
if (validPass.Succeeded)
{
user.PasswordHash = _userManager.PasswordHasher.HashPassword(model.NewPassword);
}
else
{
AddErrorsFromResult(validPass);
}
if (validPass == null || (model.NewPassword != string.Empty && validPass.Succeeded))
{
IdentityResult result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
_mailingRepository.PasswordChangedMail(user.Email);
NotifyManager.Set("notification-success", "Success!", "Your password has been changed!");
return(Json(new { url = Url.Action("Index") }));
}
else
{
AddErrorsFromResult(result);
}
}
else
{
ModelState.AddModelError("", "User Not Found");
}
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(PartialView(model));
}
public async Task <ActionResult> ChangePassword(UserChangePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.NewPassword != model.NewPasswordCopy)
{
ModelState.AddModelError("", ErrorMessage.PasswordsDontMatch);
return(View(model));
}
AppUser user = GetCurrentUser();
if (user != null)
{
bool correctPass = await _userManager.CheckPasswordAsync(user, model.OldPassword);
if (!correctPass)
{
ModelState.AddModelError("", ErrorMessage.PasswordNotValid);
return(View(model));
}
IdentityResult validPass = await _userManager.PasswordValidator.ValidateAsync(model.NewPassword);
if (validPass.Succeeded)
{
user.PasswordHash = _userManager.PasswordHasher.HashPassword(model.NewPassword);
IdentityResult result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
_mailingRepository.PasswordChangedMail(user.Email);
return(RedirectToAction("Index"));
}
else
{
AddErrorsFromResult(result);
}
}
else
{
AddErrorsFromResult(validPass);
return(View(model));
}
}
else
{
ModelState.AddModelError("", ErrorMessage.NullUser);
}
return(View(model));
}
public async Task ChangePasswordAsync_ReturnTrue()
{
var user = new UserChangePasswordViewModel
{
Id = 1,
NewPassword = "******",
};
var result = await _userService.ChangePasswordAsync(user);
Assert.True(result);
}
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel change_password)
{
var result = await userService.ChangePassword(change_password.OldPassword, change_password.NewPassword, ModelState, User);
if (!result)
{
return(View());
}
return(RedirectToAction("Index", "User"));
}
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
await _accountService.ChangePasswordAsync(model.Password);
return(Json(new { success = true, responseText = "Your message successfuly sent!" }));
}
return(PartialView("_ChangePassword", model));
}
// [Authorize("Admin")]
public async Task <IActionResult> ChangePassword([FromBody] UserChangePasswordViewModel userChangePasswordViewModel)
{
var user = await _userManager.Users.Where(e => e.Id == userChangePasswordViewModel.Id).FirstOrDefaultAsync();
var result = await _userManager.ChangePasswordAsync(user, userChangePasswordViewModel.CurrentPassword, userChangePasswordViewModel.NewPassword);
if (!result.Succeeded)
{
return(StatusCode(400, "Error during change password!"));
}
return(new OkObjectResult(result.Succeeded));
}
public async Task PostChangePassword_ReturnRedirectToActionResult()
{
var user = new UserChangePasswordViewModel()
{
Id = 1,
Email = "*****@*****.**",
NewPassword = "******"
};
var result = await _userController.ChangePassword(user);
Assert.IsType <PartialViewResult>(result);
}
public IActionResult ChangePassword(UserChangePasswordViewModel ucpvm)
{
if (ModelState.IsValid)
{
bool success =
_repository.ChangePassword(ucpvm.CurrentPassword, ucpvm.NewPassword);
if (success == true)
{
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Unable To Change Password");
return(View(ucpvm));
}
return(View(ucpvm));
//[HttpGet]
//public IActionResult Edit(int id)
//{
// User u = _repository.GetUserById(id);
// return View(u);
//}
//[HttpPost]
//public IActionResult Edit(User u)
//{
// if (ModelState.IsValid)
// {
// _repository.Update(u);
// return RedirectToAction("Details", new { id = u.UserId });
// }
// return View(u);
//}
// Delete -----------------------------------------------------------------------------------
//[HttpGet]
//public IActionResult Delete(int id)
//{
// User u = _repository.GetUserById(id);
// if (u != null)
// {
// return View(u);
// }
// return RedirectToAction("Index");
//}
//[HttpPost]
//public IActionResult Delete(User u)
//{
// _repository.Delete(u.UserId);
// return RedirectToAction("Index");
//}
}
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel model)
{
if (!await _service.UserService.ValidateKeyOfChangePassword(model.Key))
{
return(BadRequest("Key invalida"));
}
var result = await _service.UserService.ChangePasswordAsync(model);
if (!result)
{
return(NoContent());
}
return(Ok(result));
}
public IActionResult ChangePassword(UserChangePasswordViewModel ucpvm)
{
if (ModelState.IsValid)
{
bool success = _repository.ChangePassword(ucpvm.CurrentPassword, ucpvm.NewPassword);
if (success == true)
{
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Unable To Change Password");
return(View(ucpvm));
}
return(View(ucpvm));
}
public async Task <IActionResult> PostForChangePassowrd([FromBody] UserChangePasswordViewModel vm)
{
var user = await userManager.FindByNameAsync("dnetrainadmin");
var changePassword = await userManager.ChangePasswordAsync(user, vm.OldPassword, vm.Password);
if (!changePassword.Succeeded)
{
return(BadRequest("原密碼錯誤"));
}
else
{
return(Ok("密碼更改成功"));
}
}
public async Task <bool> ChangePasswordAsync(UserChangePasswordViewModel user)
{
var userResult = await _userManager.FindByNameAsync(user.UserName);
if (userResult == null)
{
return(false);
}
var newPassword = _userManager.PasswordHasher.HashPassword(userResult, user.Password);
userResult.PasswordHash = newPassword;
var result = await _userManager.UpdateAsync(userResult);
return(result.Succeeded);
}
public async Task <IActionResult> ChangePassword()
{
var user = await repository.UserManager.FindByNameAsync(User.Identity.Name);
if (user is null)
{
return(NotFound($"User with username '{User.Identity.Name}' was not found"));
}
UserChangePasswordViewModel model = new UserChangePasswordViewModel
{
Id = user.Id,
Username = user.UserName
};
return(View(model));
}
public async Task <IActionResult> ChangePassword(UserChangePasswordViewModel changePasswordModel)
{
if (ModelState.IsValid)
{
var user = await _userService.ChangePasswordAsync(changePasswordModel);
if (user)
{
TempData["SuccessMessage"] = _localizer.GetLocalizedString("msg_ChangePasswordSuccess").ToString();
return(PartialView("_ChangePasswordPartial", changePasswordModel));
}
TempData["ErrorMessage"] = _localizer.GetLocalizedString("err_ChangePassword").ToString();
return(PartialView("_ChangePasswordPartial", changePasswordModel));
}
return(PartialView("_ChangePasswordPartial", changePasswordModel));
}
public async Task <IActionResult> ChangePassword(string id)
{
User user = await userManager.FindByIdAsync(id);
if (user != null)
{
UserChangePasswordViewModel model = new UserChangePasswordViewModel
{
Id = user.Id,
Email = user.Email,
};
return(View(model));
}
return(NotFound());
}
public ActionResult ChangePassword(UserChangePasswordViewModel vm)
{
if (Request.HttpMethod != "POST")
{
return(View(vm));
}
if (!ModelState.IsValid)
{
return(View(vm));
}
Svc.User.CheckPassword(User.Identity.GetAccount(), vm.OldPassword);
Svc.User.SetPassword(User.Identity.GetUserId(), vm.Password);
TempData["StatusSuccess"] = "儲存成功!!";
return(View(vm));
}
public ActionResult EditPassword(UserChangePasswordViewModel model)
{
var user = _userService.FindBy(e => e.Uuid == model.Uuid).FirstOrDefault();
if (user == null)
{
string message = Resources.ErrorMessages.UserNotAvailable;
if (Request.IsAjaxRequest())
{
return(JsonStatusGone(message));
}
else
{
AddViewMessage(TypeMessageView.ERROR, message);
return(RedirectToAction("Index"));
}
}
if (ModelState.IsValid)
{
user.Password = SecurityUtil.EncryptPassword(model.Password);
DateTime todayDate = DateUtil.GetDateTimeNow();
DateTime passwordExpiration = todayDate.AddDays(-1);
user.PasswordExpiration = passwordExpiration;
_userService.Update(user);
string successMessage = Resources.Messages.UserPasswordUpdated;
if (Request.IsAjaxRequest())
{
return(Json(new {
Message = successMessage
}));
}
AddViewMessage(TypeMessageView.SUCCESS, successMessage);
return(RedirectToAction("Index"));
}
if (Request.IsAjaxRequest())
{
Response.StatusCode = 422;
return(Json(new
{
issue = model,
errors = ModelState.Keys.Where(k => ModelState[k].Errors.Count > 0)
.Select(k => new { propertyName = k, errorMessage = ModelState[k].Errors[0].ErrorMessage })
}));
}
return(View(model));
}
/// <inheritdoc />
/// <summary>
/// ChangePasswordAsync
/// </summary>
/// <param name="changePasswordViewModel">UserChangePasswordViewModel</param>
/// <returns>Could be Changed?</returns>
public async Task <bool> ChangePasswordAsync(UserChangePasswordViewModel changePasswordViewModel)
{
try
{
var user = await _context.Users.FindAsync(changePasswordViewModel.Id);
user.Password = SecurePasswordHasher.Hash(changePasswordViewModel.NewPassword);
_context.Users.Update(user);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
Log.Error(e.Message);
return(false);
}
}
