public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordRequestDto dto)
{
try
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(dto.Email);
if (user == null)
{
return(BadRequest());
}
var result = await _userManager.ResetPasswordAsync(user, dto.Code, dto.Password);
if (result.Succeeded)
{
return(Ok());
}
}
return(BadRequest());
}
catch (Exception ex)
{
_logger.LogError("Threw exception while resetting password for user: {@ex}", ex);
return(new StatusCodeResult(500));
}
}
public async Task ResetPassword_WhenCalledWithInValidCode_ReturnsBadRequest()
{
// Arrange
string email = "*****@*****.**";
var req = new ResetPasswordRequestDto()
{
Email = email,
Code = "0"
};
_mockUserManager
.Setup(m => m.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(_user);
_mockUserManager
.Setup(m => m.ResetPasswordAsync(It.IsAny <ApplicationUser>(), req.Code, It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Failed());
// Act
var result = await _sut.ResetPassword(req);
// Assert
Assert.IsAssignableFrom <BadRequestResult>(result);
}
public async Task <IActionResult> ResetPasswordAsync([FromBody] ResetPasswordRequestDto dto)
{
var user = await _userManager.FindByEmailAsync(dto.Email);
ValidateUserExists(user, dto);
await _userManager.ResetPasswordAsync(user, dto.Token, dto.NewPassword);
return(Ok());
}
public async Task <IActionResult> ResetPasswordRequest(ResetPasswordRequestDto resetPasswordRequestDto)
{
try
{
await _authService.ResetPasswordRequest(resetPasswordRequestDto.Email);
await _mediator.Publish(new ResetPasswordRequestNotificationEvent(resetPasswordRequestDto.Email));
}
catch (EntityNotFoundException ex)
{
return(NotFound(ex.Message));
}
return(NoContent());
}
public async Task ResetPasswordConfirmAsync(ResetPasswordRequestDto dto)
{
var user = await _userService.GetByEmailAsync(dto.Email);
if (user != null)
{
var request = _mapper.Map <PasswordResetModel, PasswordResetDto>(await _passwordResetRepository.GetPasswordResetRequestAsync(user.Id));
if (request != null && (request.Hash == dto.Hash && request.UserId == user.Id))
{
await _userService.UpdatePassword(user.Id, dto.NewPassword);
await _passwordResetRepository.UpdatePasswordResetRequestAsync(request.Id, PasswordResetStatusEnum.Done);
}
}
}
private async void ResetButton_Click(object sender, EventArgs e)
{
try
{
if (!ValidateInputs())
{
return;
}
_progressBarHelper.Show();
var dto = new ResetPasswordRequestDto()
{
Code = codeEditText.Text,
Password = passwordEditText.Text,
Email = _email
};
var res = await _authHelper.ResetPasswordAsync(dto);
_progressBarHelper.Hide();
if (res.StatusCode == HttpStatusCode.OK)
{
_dialogHelper.ShowSuccessDialog(this, "Resetting Password was successful. Please Sign In"
, (o, ea) =>
{
StartActivity(typeof(SignInActivity));
Finish();
});
}
else if (res.StatusCode == HttpStatusCode.BadRequest)
{
_dialogHelper.ShowError(this, "The code entered is incorrect.");
}
else
{
_dialogHelper.ShowError(this);
}
}
catch (Exception ex)
{
Log.WriteLine(LogPriority.Error, "Planner Error", ex.Message);
_progressBarHelper.Hide();
_dialogHelper.ShowError(this, ex);
}
}
public async Task ResetPassword(ResetPasswordRequestDto resetPasswordRequest)
{
var user = await _userManager.FindByEmailAsync(resetPasswordRequest.Email);
if (user is null)
{
throw new BadRequestException(nameof(ErrorStrings.UserNameNotFound));
}
var result = await _userManager.ResetPasswordAsync(user, resetPasswordRequest.Token, resetPasswordRequest.Password);
if (!result.Succeeded)
{
throw new ResourceValidationException(result.Errors.Select(e => e.Code).ToArray());
}
}
public async Task ResetPasswordRequest(ResetPasswordRequestDto resetPasswordRequest)
{
var user = await _storage.FindAsync(m => m.Email == resetPasswordRequest.Email);
if (user == null)
{
return;
}
user.ResetPasswordToken = TokenHelper.GenerateToken().Replace("/", "");
user.ResetPasswordTokenExpiresAt = DateTimeOffset.Now.AddMinutes(30);
await _storage.UpdateAsync(user);
var notification = new NotificationDto(user.Id);
await _notifier.SendPasswordResetNotificationAsync(notification);
}
public async Task ResetPasswordAsync(ResetPasswordRequestDto request)
{
var account = _dbContext.Accounts.SingleOrDefault(x => x.ResetToken == request.Token && x.ResetTokenExpires > DateTime.UtcNow);
if (account == null)
{
throw new AppException("Invalid token");
}
// update password and remove reset token
account.PasswordHash = BC.HashPassword(request.Password);
account.PasswordReset = DateTime.UtcNow;
account.ResetToken = null;
account.ResetTokenExpires = null;
_dbContext.Accounts.Update(account);
await _dbContext.SaveChangesAsync();
}
public async Task ResetPasswordRequest_CallWithMockedIAuthentication_ReturnsOkObjectResult()
{
// Arrange
var mock = new Mock <IAuthentication>();
var resetPasswordRequestDto = new ResetPasswordRequestDto()
{
Email = "*****@*****.**",
};
mock.Setup(auth => auth.ResetPasswordRequest(resetPasswordRequestDto)).Returns(Task.Delay(0));
var authController = new AuthController(mock.Object);
// Act
var result = await authController.ResetPasswordRequest(resetPasswordRequestDto);
// Assert
Assert.IsType <OkResult>(result);
}
public async Task <BaseResponse> ResetPasswordRequest(ResetPasswordRequestDto request)
{
var user = await userManager.FindByEmailAsync(HttpUtility.UrlDecode(request.Email));
if (user == null)
{
return(new BaseResponse(false, (int)HttpStatusCode.BadRequest, localizer["InvalidEmail"]));
}
var code = await userManager.GenerateChangePhoneNumberTokenAsync(user, user.PhoneNumber);
// [TEMPORARY] Send the code via email
//await messager.SendEmailAsync(request.Email, "Password reset code", string.Format("Your password reset code is: {0}", code));
var sendEmailResult = await messager.SendResetPasswordEmail(request.Email, code, user.PhoneNumber.Substring(user.PhoneNumber.Length - 4), user.DefaultLang);
if (!sendEmailResult.Success)
{
return(new BaseResponse(false, 700, sendEmailResult.Message));
}
return(new BaseResponse(true, (int)HttpStatusCode.OK, localizer["PasswordResetTokenSentSuccessfully"]));
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordRequestDto model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null)
{
if (!user.IsInitialSet || !user.IsActive || !user.EmailConfirmed)
{
return(BadRequest());
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
string newPassword = _authService.GeneratePassword();
var result = await _userManager.ResetPasswordAsync(user, token, newPassword);
if (result.Succeeded)
{
user.IsInitialSet = false;
await _appDbContext.SaveChangesAsync();
await _authService.InvalidateAllUnusedRefreshTokens(user);
_queue.QueueBackgroundWorkItem(async token =>
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var mailService = scope.ServiceProvider.GetRequiredService <IMailService>();
await mailService.SendResetPasswordEmailAsync(user, newPassword);
}
});
return(Ok());
}
else
{
return(BadRequest());
}
}
return(NotFound());
}
public async Task <IActionResult> ResetPasswordRequest([FromBody] ResetPasswordRequestDto request)
{
var response = await identityService.ResetPasswordRequest(request);
return(StatusCode(response.StatusCode, response));
}
public Task <HttpResponseMessage> ResetPasswordAsync(ResetPasswordRequestDto requestDto)
{
return(_httpService.PostAsync("Auth/ResetPassword", requestDto));
}
public async Task <Result> ResetPassword([FromBody] ResetPasswordRequestDto request) => await _identityUserRegistrationService.TriggerPasswordReset(request.Email);
public async Task <IActionResult> ResetPasswordRequest([FromBody] ResetPasswordRequestDto resetPasswordRequest)
{
await _authentication.ResetPasswordRequest(resetPasswordRequest);
return(Ok());
}
public async Task <IActionResult> ResetPassword(ResetPasswordRequestDto request)
{
await _accountService.ResetPasswordAsync(request);
return(Ok(new { message = "Password reset successful, you can now login" }));
}
public async Task <IActionResult> ConfirmNewPassword([FromBody] ResetPasswordRequestDto dto)
{
await _authService.ResetPasswordConfirmAsync(dto);
return(Ok());
}
