public async Task GivenEmployeeModel_WhenPutUpdatePasswordRequest_ThenReturnOk()
{
// Arrange
const string NEW_PASSWORD = "******";
var model = _fixture.Context.Users.ToList().ElementAt(5);
var viewModel = new UpdatePasswordViewModel
{
UserName = model.UserName,
Password = NEW_PASSWORD,
};
// Act
var response = await _fixture.Client.PutAsJsonAsync($"{API_URL}/update-password", viewModel);
// Assert
response.EnsureSuccessStatusCode();
var assertLogin = await AuthExtensions.GetJwt(
_fixture,
new LoginViewModel
{
UserName = model.UserName,
Password = NEW_PASSWORD,
}
);
Assert.NotEmpty(assertLogin);
}
public async Task <IActionResult> UpdatePassword(string id, [FromBody] UpdatePasswordViewModel vm)
{
if (!ModelState.IsValid)
{
var errorMessage = ModelState["Password"].Errors.First().ErrorMessage;
return(HttpBadRequest(errorMessage));
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(HttpNotFound());
}
if (!string.IsNullOrWhiteSpace(vm.Password))
{
await _userManager.RemovePasswordAsync(user);
var result = _userManager.AddPasswordAsync(user, vm.Password);
if (result.Result == IdentityResult.Success)
{
return(new HttpOkResult());
}
var error = result.Result.Errors.First().Description;
return(HttpBadRequest(error));
}
return(HttpBadRequest());
}
public async Task <ActionResult> UpdatePassword(UpdatePasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
// Не показывать, что пользователь не существует или не подтвержден
return(View("ChangePasswordError"));
}
{
var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("ChangePasswordConfirmation", "Account"));
}
// Дополнительные сведения о включении подтверждения учетной записи и сброса пароля см. на странице https://go.microsoft.com/fwlink/?LinkID=320771.
// Отправка сообщения электронной почты с этой ссылкой
return(View("ChangePasswordError"));
}
}
// Появление этого сообщения означает наличие ошибки; повторное отображение формы
return(View("ChangePasswordError"));
}
public async Task <ActionResult> UpdatePassword(UpdatePasswordViewModel model, string userId, string newPassword)
{
SWGDealerDbContext context = new SWGDealerDbContext();
UserStore <AppUser> store = new UserStore <AppUser>(context);
UserManager <AppUser> userManager = new UserManager <AppUser>(store);
userId = User.Identity.GetUserId();
if (!ModelState.IsValid)
{
return(View("UpdatePassword"));
}
else
{
newPassword = model.ConfirmPassword;
string hashedNewPassword = userManager.PasswordHasher.HashPassword(newPassword);
AppUser identityUser = await store.FindByIdAsync(userId);
await store.SetPasswordHashAsync(identityUser, hashedNewPassword);
await store.UpdateAsync(identityUser);
TempData["PasswordUpdate"] = "Password has been successfully updated!";
return(View("UpdatePassword"));
}
}
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var user = await userService.UpdatePasswordAsync(model.UserId, model.Password);
return(Ok());
}
catch (NullReferenceException ex)
{
logger.LogError(ex.Message, ex);
return(NotFound());
} catch (Exception ex)
{
logger.LogError(ex.Message, ex);
ModelState.AddModelError(String.Empty, "Cannot update user password");
return(BadRequest(ModelState));
}
}
public async Task <ApiResponseDto> UpdatePassword(UpdatePasswordViewModel parameters)
{
ApiResponseDto apiResponse = await _accountApiClient.UpdatePassword(parameters);
NotifyAuthenticationStateChanged(GetAuthenticationStateAsync());
return(apiResponse);
}
public async Task <ActionResult> UpdatePassword(UpdatePasswordViewModel viewModel)
{
var updateResult = await _profileAppService.UpdatePassword(new UpdatePasswordDto
{
CurrentPassword = viewModel.CurrentPassword,
NewPassword = viewModel.NewPassword
});
if (updateResult.Succeeded)
{
return(Ok());
}
var errorDesc = "";
foreach (var error in updateResult.Errors)
{
errorDesc = error.Description;
//if (error.Code == "PasswordMismatch") throw new UserFriendlyException(error.Description);
}
return(BadRequest(errorDesc));
//return StatusCode(200);
}
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await GetCurrentUserAsync();
if (user != null)
{
byte[] bytes = Convert.FromBase64String(model.OldPassword);
string oldPassword = Encoding.UTF8.GetString(bytes);
var result = await _userManager.ChangePasswordAsync(user, oldPassword, model.NewPassword);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User changed their password successfully.");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
return(View(model));
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model)
{
if (ModelState.IsValid)
{
if (model.NewPassword == model.ConfirmPassword)
{
var result = await _userManager.ChangePasswordAsync(await _userManager.GetUserAsync(User), model.CurrentPassword, model.NewPassword);
if (result.Succeeded)
{
TempData["success"] = "Password updated!";
return(RedirectToAction("Profile"));
}
else
{
TempData["error"] = $"Error: ";
foreach (var error in result.Errors)
{
TempData["error"] += $"{error.Description}. ";
}
return(View());
}
}
else
{
TempData["error"] = $"Passwords do not match";
return(RedirectToAction("UpdatePassword"));
}
}
return(RedirectToAction("Profile"));
}
public async Task <JsonResult> Put(int id, [FromBody] UpdatePasswordViewModel password)
{
Logger.Fatal(this.Request.Log());
var isAuthorized = await CheckUserAuthorized(id);
if (isAuthorized.StatusCode != 200)
{
return(isAuthorized);
}
// All was well
var pass = await _context.Password.FirstOrDefaultAsync(x => x.Id == id);
if (pass == null)
{
return(404.ErrorStatusCode());
}
// Update old pass
pass.PasswordText = password.PasswordText.Encrypt(_configuration.GetConnectionString("Enc"));
pass.Hint = password.Hint;
// Save changes
_context.Password.Update(pass);
_context.SaveChanges();
return(202.SuccessStatusCode());
}
public async Task <IActionResult> UpdatePassword(string userId)
{
if (userId == null)
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound());
}
var loggedInUser = await _userManager.FindByNameAsync(HttpContext.User.Identity.Name);
if (user.Id != loggedInUser.Id)
{
return(NotFound());
}
var updatePasswordViewModel = new UpdatePasswordViewModel
{
UserId = user.Id
};
return(View());
}
public IActionResult UpdatePassword(UpdatePasswordViewModel model)
{
ViewData[AccountConstants.SuccessPasswordUpdate] = false;
if (ModelState.IsValid)
{
try
{
var updateUserPasswordContract = new UpdateUserPasswordContract
{
NewPassword = model.Password,
OldPassword = model.OldPassword
};
var client = GetUserClient();
client.UpdateCurrentPassword(updateUserPasswordContract);
ViewData[AccountConstants.SuccessPasswordUpdate] = true;
return(PartialView("UserProfile/_UpdatePassword", null));
}
catch (HttpErrorCodeException e)
{
AddErrors(e);
}
catch (MainServiceException e)
{
AddErrors(e);
}
}
return(PartialView("UserProfile/_UpdatePassword", model));
}
public async Task <JsonResult> UpdatePassword(UpdatePasswordViewModel model)
{
if (HasPassword())
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(Json(new
{
result = "success"
}));
}
else
{
return(Json(new
{
result = "failed",
}));
}
}
}
return(Json(new
{
result = "failed",
data = ModelState.Select(x => new { Field = x.Key, Error = x.Value.Errors }).ToList()
}));
}
public ApiResult <UpdatePasswordViewModel> UpdatePassword(UpdatePasswordViewModel model)
{
var dbResult = new ApiResult <UpdatePasswordViewModel>();
try
{
// Validate dữ liệu
if (!ValidateUpdatePassword(model).Succeeded)
{
return(ValidateUpdatePassword(model));
}
// Đặt lại mật khẩu trong database
model.NewPassword = Libs.GetMd5(model.NewPassword + EncryptCore.PassKey);
model.NewPassword = model.NewPassword;
dbResult = userDAL.UpdatePassword(model);
return(dbResult);
}
catch (Exception ex)
{
dbResult.Failed(new ErrorObject()
{
Code = Constants.ERR_EXCEPTION,
Description = ex.Message
});
return(dbResult);
}
}
public ActionResult Index(string option, string userType)
{
if (option != null)
{
switch (option.ToLower())
{
case "updateinfo":
{
_viewModel = new UpdateInfoViewModel();
CreateLayoutView("Cập nhật thông tin");
break;
}
case "updatepassword":
{
_viewModel = new UpdatePasswordViewModel();
CreateLayoutView("Cập nhật mật khẩu");
break;
}
case "updatesetting":
{
_viewModel = new UpdateSettingViewModel();
CreateLayoutView("Cài đặt");
break;
}
case "notification":
{
_viewModel = new NotificationViewModel();
CreateLayoutView("Thông báo");
break;
}
case "requests":
{
_viewModel = new RequestsViewModel();
CreateLayoutView("Lời mời kết bạn");
break;
}
default:
{
_viewModel = new UpdateInfoViewModel();
CreateLayoutView("Cập nhật thông tin");
break;
}
}
}
else
{
_viewModel = new UpdateInfoViewModel();
CreateLayoutView("Cập nhật thông tin");
}
ViewBag.newMember = userType;
ViewBag.listRequest = _friendService.GetRelationship(User.Identity.GetUserId()).Count - 1;
ViewBag.listNotification = _notificationService.getAllNotification(User.Identity.GetUserId()).Count - 1;
return(View(_viewModel));
}
public async Task <IActionResult> UpdatePassword([Bind("ProjectId, AssetId, Password")] UpdatePasswordViewModel updatePasswordViewModel)
{
if (updatePasswordViewModel == null)
{
throw new ArgumentNullException(nameof(updatePasswordViewModel));
}
if (ModelState.IsValid)
{
// check valid project, do not decrypt, checks access
var project = await _projectsService.GetProject(updatePasswordViewModel.ProjectId, true);
if (project == null)
{
return(NotFound());
}
// get the current user IP
string accessIpAddress = HttpContext?.Connection?.RemoteIpAddress?.ToString();
// Perform the credential update
await _assetService.UpdateAssetPasswordAsync(
updatePasswordViewModel.ProjectId,
updatePasswordViewModel.AssetId,
updatePasswordViewModel.Password,
accessIpAddress);
}
else
{
return(BadRequest("Model is invalid."));
}
return(RedirectToAction(nameof(Details), new { id = updatePasswordViewModel.ProjectId }));
}
public async Task <IActionResult> ChangePassword([FromBody] UpdatePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var adminUser = _userRepository.GetByKey(model.UserId.Value);
if (adminUser == null)
{
return(new JsonResult(new
{
success = false,
Message = "修改失败"
}));
}
var pwdVerification = _passwordHasher.VerifyHashedPassword(
adminUser,
adminUser.UserPassword,
model.CurrentPassword);
if (pwdVerification == PasswordVerificationResult.Success ||
pwdVerification == PasswordVerificationResult.SuccessRehashNeeded)
{
adminUser.UserPassword = _passwordHasher.HashPassword(adminUser, model.NewPassword);
_userRepository.Update(adminUser);
var state = await _unitOfWork.SaveAsync();
return(Json(state));
}
return(Json(false));
}
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await userHelper.FindByEmailAsync(User.Identity.Name);
if (user != null)
{
var result = await userHelper.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction(nameof(Settings)));
}
else
{
ModelState.AddModelError(string.Empty, result.Errors.FirstOrDefault().Description);
}
}
else
{
ModelState.AddModelError(string.Empty, "Usuario no encontrado");
}
}
return(View(model));
}
public ActionResult UpdatePasswordDB(UpdatePasswordViewModel vm)
{
if (!ModelState.IsValid)
{
return(View("UpdatePassword", vm));
}
int id = (int)Session["User"];
if (Hash(vm.Password) == _context.NWUsers.SingleOrDefault(x => x.Id.Equals(id)).Password)//db.GetUserById((int)Session["User"]).Password)
{
_context.NWUsers.SingleOrDefault(x => x.Id.Equals(id)).Password = Hash(vm.NewPassword);
_context.SaveChanges();
return(RedirectToAction("ViewUserData"));
//if (db.UpdatePassword((int)Session["User"], vm.NewPassword))
//{
// ViewBag.Error = null;
// return RedirectToAction("ViewUserData");
//}
//else
//{
// ViewBag.Error = "Adatbázis hiba történt!";
// return View("ViewUserData");
//}
}
else
{
ViewBag.Error = "Nem jól adta meg jelenlegi jelszavát!";
return(View("UpdatePassword"));
}
}
public IActionResult UpdatePassword(UpdatePasswordViewModel UpdatePasswordViewModel)
{
var account = _authRepository.CheckByToken(_user.Token);
if (ModelState.IsValid)
{
if (!Crypto.VerifyHashedPassword(account.Password, UpdatePasswordViewModel.CurrentPassword))
{
return Ok(new
{
message = "Password is Not Valid!",
status=false
});
}
if(_authRepository.UpdatePassword(_user.Id, UpdatePasswordViewModel.Password))
{
return Ok(new
{
message = "Password Updated Successfully!",
status = true
});
}
}
return View("Views/Pages/Chat1.cshtml", new GeneralViewModel
{
UpdatePasswordViewModel = UpdatePasswordViewModel,
AccountDetailViewModel = _mapper.Map<Account, AccountDetailViewModel>(_authRepository.CheckByToken(_user.Token))
});
}
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
if (ModelState.IsValid)
{
var verifyHashed = _passwordHasher.VerifyHashedPassword(user, user.PasswordHash, model.OldPassword);
if (verifyHashed == PasswordVerificationResult.Success)
{
user.PasswordHash = _passwordHasher.HashPassword(user, model.NewPassword);
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
await _signInManager.SignOutAsync();
await _signInManager.SignInAsync(user, true);
return(RedirectToAction("Index"));
}
ModelState.AddIdentityError(result.Errors);
return(View(model));
}
ModelState.AddModelError(nameof(model.OldPassword), Messages.OldPasswordFail);
return(View(model));
}
return(View(model));
}
public async Task <IActionResult> AlterarSenhaUsuarioLogado([FromBody] UpdatePasswordViewModel model, int version)
{
if (version == 2)
{
return(Response(new { Message = "API V2 não disponível" }));
}
var userEF = await _userManager.FindByIdAsync(model.Id);
if (userEF == null || string.IsNullOrEmpty(userEF.Email) || userEF.Email != model.Email)
{
return(Response(new { Message = "Não foi possível localizar o usuário na base de dados." }));
}
if (!ModelState.IsValid)
{
NotifyErrorInvalidModel();
return(Response());
}
var result = await _userManager.ChangePasswordAsync(userEF, model.SenhaAtual, model.NovaSenha);
if (result.Succeeded)
{
_logger.LogInformation(1, "Senha alterada com sucesso!");
var response = new { Message = "Senha alterada com sucesso!" };
return(Response(response));
}
AddIdentityErrors(result);
return(Response(model));
}
public ActionResult UpdatePassword()
{
UpdatePasswordViewModel updatePasswordViewModel = new UpdatePasswordViewModel();
AdminProfileViewModel adminProfileViewModel = (AdminProfileViewModel)Session["EmployeeObj"];
updatePasswordViewModel.EmployeeID = adminProfileViewModel.EmployeeID;
return(View(updatePasswordViewModel));
}
public IActionResult UpdatePassword()
{
var loginId = User.Identity.Name;
var model = new UpdatePasswordViewModel();
return(View(model));
}
/// <summary>
/// 修改密碼
/// </summary>
/// <returns></returns>
public ActionResult Password()
{
var model = new UpdatePasswordViewModel
{
ExistPassword = service.ExistPassword(SessionManager.UserID)
};
return(PartialView(ViewName("Member", "Password"), model));
}
public ActionResult UpdatePassword()
{
_viewModel = new UpdatePasswordViewModel();
CreateLayoutView("Quản lý tài khoản");
ViewBag.listRequest = _friendService.GetRelationship(User.Identity.GetUserId()).Count - 1;
ViewBag.listNotification = _notificationService.getAllNotification(User.Identity.GetUserId()).Count - 1;
return(PartialView("_UpdatePassword", UpdatePasswordViewModel));
}
public async Task <IActionResult> UpdatePassword()
{
var user = await _userService.FetchCurrentUser();
var model = new UpdatePasswordViewModel();
model.Kund = _userService.FetchCurrentCustomer(user.Id);
return(View(model));
}
public async Task <IActionResult> OnGet()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound());
}
UpdatePasswordViewModel = new UpdatePasswordViewModel();
return(Page());
}
public ActionResult Password(UpdatePasswordViewModel model)
{
var result = service.UpdatePassword(SessionManager.UserID, model);
//重新登入
if (result.IsSuccess)
{
SessionManager.RemoveAll();
}
return(Json(result));
}
public ActionResult ChangePassword(UpdatePasswordViewModel model)
{
if (CurrentUser == null)
{
return(new HttpUnauthorizedResult());
}
model.CurrentUser = CurrentUser;
model.UserId = CurrentUser.Id;
return(View(model));
}
