public async Task <Result> ResetPassword(ResetPassword resetPassword)
{
var validator = new ResetPasswordValidator();
var result = validator.Validate(resetPassword).GetResult();
if (!result.Success)
{
return(result);
}
var user = await _userManager.FindByNameAsync(resetPassword.UserName);
var activateResult = await _userManager.ResetPasswordAsync(user, resetPassword.Token, resetPassword.Password);
if (!activateResult.Succeeded)
{
foreach (var error in activateResult.Errors)
{
result.AddValidationFailure("", error.Description);
}
return(result);
}
if (!user.EmailConfirmed)
{
user.EmailConfirmed = true;
await _userManager.UpdateAsync(user);
}
return(result);
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPassword.InModel inModel)
{
ResetPasswordValidator resetPasswordValidator = new ResetPasswordValidator();
await resetPasswordValidator.ValidateAndThrowAsync(inModel);
await _userService.ResetPasword(inModel.IdUser, inModel.NewPasswordHash, inModel.OldPasswordHash);
return(Ok());
}
public void ValidWhenAllDataProvided()
{
// arrange
var validator = new ResetPasswordValidator();
var dto = new ResetPasswordDto
{
Email = validEmail,
Token = validToken,
Password = validPassword,
ConfirmedPassword = validPassword
};
// act
var result = validator.Validate(dto);
// assert
Assert.True(result.IsValid);
}
public void InvalidWhenPasswordDifferentThanConfirmedPassword()
{
// arrange
var validator = new ResetPasswordValidator();
var dto = new ResetPasswordDto
{
Email = validEmail,
Token = validToken,
Password = validPassword,
ConfirmedPassword = differentPassword
};
// act
var result = validator.Validate(dto);
// assert
Assert.False(result.IsValid);
}
public void InvalidWhenPasswordNotProvided(string password)
{
// arrange
var validator = new ResetPasswordValidator();
var dto = new ResetPasswordDto
{
Email = validEmail,
Token = validToken,
Password = password,
ConfirmedPassword = password
};
// act
var result = validator.Validate(dto);
// assert
Assert.False(result.IsValid);
}
public ResponseModel ResetPassword(ResetPassword model)
{
ResponseModel response = new ResponseModel();
ValidationResult validateResetPassword = new ResetPasswordValidator().Validate(model);
if (validateResetPassword.IsValid)
{
try
{
bool validateToken = JWTService.ValidateToken(model.Token, _signingConfiguration, _tokenConfiguration);
if (validateToken)
{
User user = _userRepository.GetById(model.Id);
if (user == null)
{
response.Message = "Usuário não encontrado";
return(response);
}
user.Password = Encrypt.EncryptString(model.Password, user.UserId.ToString());
user.UpdatedBy = model.Id;
user.LastUpdatedAt = DateTime.Now;
_userRepository.Edit(user);
response.Success = true;
response.Message = "Senha alterada com sucesso";
}
else
{
response.Message = "Token expirado";
}
}
catch (Exception)
{
response.Message = "Erro ao alterar senha, entre em contato com suporte";
}
}
else
{
response.Message = validateResetPassword.Errors.FirstOrDefault().ErrorMessage;
}
return(response);
}
public void Should_ReturnFalse_WhenRequiredInfo_IsNotProvided(string email, string password, string passwordResetToken)
{
// Arrange
var resetPasswordDto = new ResetPasswordDto
{
Email = email,
Password = password,
PasswordResetToken = passwordResetToken
};
var resetPasswordValidator = new ResetPasswordValidator();
// Act
var validatorResult = resetPasswordValidator.Validate(resetPasswordDto);
// Assert
validatorResult.IsValid.ShouldBeFalse();
}
public async Task Should_ReturnTrue_WhenRequiredInfo_IsProvided()
{
// Arrange
var resetPasswordDto = new ResetPasswordDto
{
Email = "*****@*****.**",
Password = "******",
PasswordResetToken = "1234xyz"
};
var resetPasswordValidator = new ResetPasswordValidator();
// Act
var validatorResult = await resetPasswordValidator.ValidateAsync(resetPasswordDto);
// Assert
validatorResult.IsValid.ShouldBeTrue();
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordDto resetPasswordDto, [FromServices] IResetPasswordService service)
{
var resetPasswordValidator = new ResetPasswordValidator();
var validatorResult = await resetPasswordValidator.ValidateAsync(resetPasswordDto);
if (validatorResult.IsValid)
{
await service.ResetPassword(resetPasswordDto);
if (!service.Status.HasErrors)
{
return(Ok());
}
return(BadRequest(service.Status.Errors));
}
var validationErrors = validatorResult.Errors.Select(error => new ValidationResult(error.ErrorMessage))
.ToImmutableList();
return(BadRequest(validationErrors));
}
public UserController(IMyUser user,
IMyFiles myFiles,
UserModelValidator userModelValidator,
UpdateUserModelValidator updateUserModelValidator,
SendEmailConfirmationValidator sendEmailConfirmationValidator,
ConfirmEmailValidator confirmEmailValidator,
ChangePasswordValidator changePasswordValidator,
ForgotPasswordValidator forgotPasswordValidator,
ResetPasswordValidator resetPasswordValidator,
ResponseBadRequest badRequest)
{
_user = user;
_myFiles = myFiles;
_badRequest = badRequest;
_userModelValidator = userModelValidator;
_updateUserModelValidator = updateUserModelValidator;
_sendEmailConfirmationValidator = sendEmailConfirmationValidator;
_confirmEmailValidator = confirmEmailValidator;
_changePasswordValidator = changePasswordValidator;
_forgotPasswordValidator = forgotPasswordValidator;
_resetPasswordValidator = resetPasswordValidator;
}
