public async Task <IHttpActionResult> ChangePasswordAsync([FromBody] UserChangePasswordDTO user)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (user is null)
{
return(BadRequest());
}
if (!user.NewPassword.Equals(user.NewPasswordConfirm))
{
return(BadRequest("New password different"));
}
try
{
var result = await _userService.ChangePassword(user);
if (result.IsSuccess)
{
return(Ok());
}
else
{
return(BadRequest(result.Message));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <string> ChangePassword(UserChangePasswordDTO userChange)
{
User user = await _eFUnitOfWork.UserManager.FindByIdAsync(Convert.ToString(userChange.Id));
if (user != null)
{
var result =
await _eFUnitOfWork.UserManager.ChangePasswordAsync(user, userChange.OldPassword, userChange.NewPassword);
if (result.Succeeded)
{
user.Password = userChange.NewPassword;
return("Пароль успішно змінено!");
}
else
{
string ErrorMessage = "";
foreach (var error in result.Errors)
{
ErrorMessage += error.Description + "\n";
}
return(ErrorMessage);
}
}
return("Користувача не існує!");
}
public async Task <IActionResult> ChangePassword([FromBody] UserChangePasswordDTO userChangePassword)
{
try {
if (userChangePassword == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, new PasswordActionAnswer()
{
ServerMessage = "Argument is null"
}));
}
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status400BadRequest, new PasswordActionAnswer()
{
ServerMessage = ModelState.ToString()
}));
}
string userEmail = this.GetCurrentUserEmail();
if (String.IsNullOrWhiteSpace(userEmail))
{
return(StatusCode(StatusCodes.Status400BadRequest, new PasswordActionAnswer()
{
ServerMessage = "Cant get current user data"
}));
}
var currentUser = await _UserManager.FindByEmailAsync(userEmail);
if (currentUser == null)
{
return(StatusCode(StatusCodes.Status404NotFound, new PasswordActionAnswer()
{
ServerMessage = "User not found"
}));
}
var result = await _UserManager.ChangePasswordAsync(currentUser, userChangePassword.CurrentPassword, userChangePassword.NewPassword);
if (result.Succeeded)
{
return(StatusCode(StatusCodes.Status202Accepted, new PasswordActionAnswer()
{
ServerMessage = "Password changed succesfully"
}));
}
else
{
return(StatusCode(StatusCodes.Status417ExpectationFailed, new PasswordActionAnswer()
{
ServerMessage = "Cant change password"
}));
}
}
catch (Exception e) {
_Logger.LogError("Change password operation failed because of exception", e);
return(StatusCode(StatusCodes.Status500InternalServerError, new PasswordActionAnswer()
{
ServerMessage = "Something went wrong"
}));
}
}
public async Task <ActionResult> ChangePassword([FromBody] UserChangePasswordDTO password)
{
var request = new ChangePasswordCommand(User.Identity?.Name, password);
var response = await _mediator.Send(request);
return(response.Match <ActionResult>(
ok => Ok(),
invalidCredentials => BadRequest("Invalid old password")
));
}
public async Task <Result> ChangePassword(UserChangePasswordDTO user)
{
var usermodel = _mapper.Map <UserChangePasswordDTO, UserChangePassword>(user);
try
{
var result = await _usersContext.ChangePassword(usermodel);
return(result ? Result.Ok() : Result.Fail("PasswordChange Error"));
}
catch
{
return(Result.Fail("Error in change password"));
}
}
public async Task ChangePassword(UserChangePasswordDTO userChangePasswordDTO, int userId)
{
var userEntity = await _context.Users.SingleOrDefaultAsync(u => u.Id == userId);
if (!SecurityHelper.ValidatePassword(userChangePasswordDTO.Password, userEntity.PasswordHash, userEntity.PasswordSalt))
{
throw new InvalidUsernameOrPasswordException("wrong password");
}
var salt = SecurityHelper.GetRandomBytes();
userEntity.PasswordSalt = Convert.ToBase64String(salt);
userEntity.PasswordHash = SecurityHelper.HashPassword(userChangePasswordDTO.NewPassword, salt);
await _context.SaveChangesAsync();
}
//-> Change Password
public async Task<UserViewDTO> ChangePassword(UserChangePasswordDTO changePasswordDTO)
{
var user = (UserViewDTO)HttpContext.Current.Session["user"];
var password = CryptingHelper.EncryptString(changePasswordDTO.password);
var checkRecord = await db.tblUsers.FirstOrDefaultAsync(x => x.deleted == null && x.id == user.id && x.password == password);
if (checkRecord == null)
throw new HttpException((int)HttpStatusCode.BadRequest, ConstantHelper.INCORRECT_PASSWORD);
if(changePasswordDTO.newPassword != changePasswordDTO.comfirmPassword)
throw new HttpException((int)HttpStatusCode.BadRequest, ConstantHelper.PASSWORD_DOES_NOT_MATCH);
checkRecord.password = CryptingHelper.EncryptString(changePasswordDTO.newPassword);
await db.SaveChangesAsync();
return await SelectByID(checkRecord.id);
}
public ActionResult ChangePassword([FromBody] UserChangePasswordDTO userDTO)
{
if (ModelState.IsValid)
{
var user = _userRepository.Get(userDTO.Email);
if (user == null)
{
return(NotFound("Usuário não encontrado."));
}
if (!_userRepository.CheckPassword(user, userDTO.PasswordCurrent))
{
return(NotFound("Senha atual inválida."));
}
user.PasswordHash = userDTO.PasswordNew;
var result = _userRepository.ChangePassword(user, userDTO.PasswordNew);
if (!result.Succeeded)
{
List <string> errors = new List <string>();
foreach (var error in result.Errors)
{
errors.Add(error.Description);
}
return(UnprocessableEntity(errors));
}
else
{
return(Ok("Senha alterada com sucesso."));
}
}
else
{
return(UnprocessableEntity(ModelState));
}
}
public void UpdatePwd(long userId, UserChangePasswordDTO dto)
{
User user = _context.Users.Where(p => p.Id == userId).SingleOrDefault();
if (user == null)
{
throw new NotImplementedException();
}
string oldPasswordHash = CommonHelper.CalcMD5(user.PassWordSalt + dto.OldPassw0rd);
if (oldPasswordHash != user.PassWordHash)
{
throw new NotImplementedException();
}
user.PassWordSalt = CommonHelper.CreateVerifyCode(5);
string pwdHash = CommonHelper.CalcMD5(user.PassWordSalt + dto.NewPassw0rd);
user.PassWordHash = pwdHash;
_context.SaveChanges();
}
public async Task <IActionResult> ChangePassword(UserChangePasswordDTO userChangePasswordDto)
{
if (ModelState.IsValid)
{
var nameOfCurrentUser = HttpContext.User.Identity.Name;
var user = await _userManager.FindByNameAsync(nameOfCurrentUser);
if (user != null)
{
IdentityResult result =
await _userManager.ChangePasswordAsync(user, userChangePasswordDto.OldPassword, userChangePasswordDto.NewPassword);
if (result.Succeeded)
{
await _emailService.SendAsync(ChangePasswordSettings.subject,
ChangePasswordSettings.GetMessage(user.Email, userChangePasswordDto.NewPassword),
user.Email);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Користувач незнайдений");
}
}
else
{
ModelState.AddModelError(string.Empty, "Неправильно введені дані");
}
return(PartialView(userChangePasswordDto));
}
public async Task <JsonResult> ChangePassword(UserChangePasswordDTO changePasswordDTO)
{
try
{
if (!ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, ConstantHelper.KEY_IN_REQUIRED_FIELD);
}
Response.StatusCode = 200;
return(Json(await handler.ChangePassword(changePasswordDTO), JsonRequestBehavior.AllowGet));
}
catch (HttpException ex)
{
if (ex.Message == ConstantHelper.INCORRECT_PASSWORD || ex.Message == ConstantHelper.PASSWORD_DOES_NOT_MATCH || ex.Message == ConstantHelper.KEY_IN_REQUIRED_FIELD)
{
Response.StatusCode = 400;
}
else
{
Response.StatusCode = 500;
}
return(Json(ex.Message, JsonRequestBehavior.AllowGet));
}
}
public async Task UpdatePassword([FromBody] UserChangePasswordDTO userChangePasswordDTO)
{
var userId = this.GetUserIdFromToken();
await _userService.ChangePassword(userChangePasswordDTO, userId);
}
public ChangePasswordCommand(string?userLogin, UserChangePasswordDTO changePasswordDTO) : base(userLogin)
{
ChangePasswordDTO = changePasswordDTO;
}
public async Task <IActionResult> ChangePassword([FromBody] UserChangePasswordDTO user)
{
return(Ok(await _userService.ChangePassword(user)));
}
