public async Task <IActionResult> PostResendConfirmEmailMessageAsync(UserEmailDto model)
{
try
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
_logger.LogError(LoggingEvents.GetItemNotFound, "User Not found");
return(NotFound("User not found"));
}
if (user.EmailConfirmed)
{
_logger.LogError(LoggingEvents.UpdateItemNotFound, "User email is already confirmed");
return(Ok());
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var url = _urlService.GetConfirmEmailUrl(user.UserName, code);
var templateData = new { username = user.UserName, url = url };
// await _emailSender.SendEmailConfirmationEmailAsync(templateData);
await _emailSender.SendTemplateEmail("d-882e4b133cae40268364c8a929e55ea9", user.Email, templateData);
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.UpdateItemNotFound, ex, "An error occurred in resend email confirmation.");
return(BadRequest("An error occurred"));
}
}
public async Task <UserEmailDto> PutUserEmail(int id, UserEmailDto model)
{
var url = CRMApiUri + "/UserEmail/" + id;
var result = await PutRequestToApi(url, model);
return(result);
}
public async Task <UserEmailDto> PostUserEmail(UserEmailDto model)
{
var url = CRMApiUri + "/UserEmail";
var result = await PostRequestToApi(url, model);
return(result);
}
public async Task <IActionResult> ResendConfirmationEmail([FromBody] UserEmailDto userEmail)
{
try
{
if (userEmail == null)
{
return(BadRequest());
}
var user = await userManager.FindByEmailAsync(userEmail.Email);
if (user == null)
{
return(NotFound());
}
if (!user.IsEnabled)
{
throw new ApplicationException("Usuario deshabilitado.");
}
if (user.EmailConfirmed)
{
throw new ApplicationException("El correo ingresado ya fue confirmado");
}
await sendConfirmationEmailService.Send(user.Id, user.Email, "", await userManager.GenerateEmailConfirmationTokenAsync(user));
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = ex.Message }));
}
}
public async Task <GenericResponse> ForgotPassword(UserEmailDto userEmailDto)
{
try
{
var identityUser = await this.dataService.UserManager.FindByEmailAsync(userEmailDto.Email);
if (identityUser == null)
{
return(GenericResponseBuilder.Success());
}
var token = await dataService.UserManager.GeneratePasswordResetTokenAsync(identityUser);
var configKey = "UIPageAddresses:ResetPasswordFormPageAddress";
var emailObject = GenerateEmailLink(identityUser, configKey, token, "email");
var passwordEmail = this.mapper.Map <ForgotPasswordEmail>(emailObject);
var emailSent = await this.emailProvider.SendForgotPasswordEmail(passwordEmail);
if (!emailSent)
{
return(GenericResponseBuilder.NoSuccess("Email send failed"));
}
return(GenericResponseBuilder.Success());
}
catch (Exception ex)
{
logger.LogError(string.Format("Error in BLL - ForgotPassword. {0}", ex.Message));
return(GenericResponseBuilder.NoSuccess(ex.Message.ToString()));
}
}
public async Task <IActionResult> SendPasswordResetLink([FromBody] UserEmailDto userEmail)
{
try
{
if (userEmail == null)
{
return(BadRequest());
}
var user = await userManager.FindByEmailAsync(userEmail.Email);
if (user == null)
{
return(NotFound());
}
if (!user.IsEnabled)
{
throw new ApplicationException("Usuario deshabilitado.");
}
await sendResetPasswordService.Send(user.Id, user.Email, await userManager.GeneratePasswordResetTokenAsync(user));
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = ex.Message }));
}
}
// POST: api/Accounts/forgotpassword
public async Task <IActionResult> ForgotPassword(
[FromBody] UserEmailDto userEmailDto)
{
var response = await businessLogic.ForgotPassword(userEmailDto);
if (response.IsSuccessful)
{
return(Ok());
}
return(BadRequest(new { message = response.ErrorMessage }));
}
public async Task <IActionResult> ResendConfirmationEmail(TUserDtoKey id)
{
if (EqualityComparer <TUserDtoKey> .Default.Equals(id, default))
{
return(NotFound());
}
var userDto = await _identityService.GetUserAsync(id.ToString());
var emailDto = new UserEmailDto <TUserDtoKey>();
emailDto.UserId = id;
emailDto.UserName = userDto.UserName;
return(View(emailDto));
}
public async Task <IActionResult> ChangeEmail(int id, [FromBody] UserEmailDto email)
{
var userId = int.Parse(this.User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (userId != id)
{
return(Unauthorized());
}
var userFromRepo = await _repo.GetUser(id);
userFromRepo.Email = email.Email;
if (await _repo.SaveAll())
{
return(NoContent());
}
return(BadRequest());
}
public async Task PostForgotPasswordAsync_ReturnsOkResult_WhenUserEmailIsNotConfirmed()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
mockUserManager.Setup(repo => repo.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(GetValidTestUser(false));
var controller = new AccountController(_systemClock.Object, _urlService.Object, _emailSender.Object, _logger.Object, mockUserManager.Object);
var testModel = new UserEmailDto()
{
};
// Act
var result = await controller.PostForgotPasswordAsync(testModel);
// Assert
var objectResult = Assert.IsType <OkResult>(result);
Assert.Equal(StatusCodes.Status200OK, objectResult.StatusCode);
}
public async Task ResendConfirmEmailMessageAsync_ReturnsOk_WhenSuccessful()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
var testUser = GetValidTestUser(false);
mockUserManager.Setup(repo => repo.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(testUser);
var testCode = "myTestCode";
mockUserManager.Setup(um => um.GenerateEmailConfirmationTokenAsync(It.IsAny <ApplicationUser>()))
.ReturnsAsync(testCode);
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.Development.json")
.Build();
var urlService = new UrlService(config);
var controller = new AccountController(_systemClock.Object, urlService, _emailSender.Object, _logger.Object, mockUserManager.Object);
var testModel = new UserEmailDto()
{
};
// Act
var result = await controller.PostResendConfirmEmailMessageAsync(testModel);
// Assert
Assert.IsType <OkResult>(result);
//Assert.NotNull(objectResult);
//Assert.True(objectResult is OResult);
//Assert.Equal(StatusCodes.Status200OK, objectResult.StatusCode);
//var expected = new Uri($"{config["Url:ConfirmEmailUrl"]}?username={testUser.UserName}&code={testCode}");
//objectResult.Value.Should().BeOfType<Uri>();
//objectResult.Value.Should().BeEquivalentTo(expected);
}
public async Task <IActionResult> PostForgotPasswordAsync(UserEmailDto model)
{
try
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
_logger.LogError(LoggingEvents.GetItemNotFound, $"User with email '{model.Email}' was not found at forgot password");
return(Ok()); // user does not exist, but don't reveal that the user does not exist
}
if (user.EmailConfirmed == false)
{
_logger.LogError(LoggingEvents.GetItemNotFound, $"Forgot password request when email '{model.Email}' is not confirmed");
return(Ok()); // email is not confirmed
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var url = _urlService.GetResetPasswordUrl(code);
// message.SetTemplateId("d-37733c23b2eb4c339a011dfadbd42b91");
// message.SetTemplateData(new ConfirmEmailDto { Username = accountDetails.Username, Url = accountDetails.Url });
//var templateData = new ResetPasswordEmailDto { Email = model.Email, Url = url, Username = user.UserName };
var templateData = new { username = user.UserName, url = url };
//await _emailSender.SendResetPasswordEmailAsync(templateData);
await _emailSender.SendTemplateEmail("d-37733c23b2eb4c339a011dfadbd42b91", model.Email, templateData);
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.UpdateItemNotFound, ex, "An error occurred in forgot password.");
return(BadRequest("An error occurred"));
}
}
public async Task <IActionResult> DisableUser([FromBody] UserEmailDto userInfo)
{
try {
if (userInfo == null)
{
return(BadRequest());
}
var user = await userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
throw new ApplicationException("Usuario no encontrado.");
}
user.IsEnabled = false;
var result = await userManager.UpdateAsync(user);
return(Ok());
}
catch (Exception ex) {
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = ex.Message }));
}
}
public async Task PostForgotPasswordAsync_ReturnsBadRequest_WhenExceptionIsRaised()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
mockUserManager.Setup(repo => repo.FindByEmailAsync(It.IsAny <string>()))
.ThrowsAsync(new InvalidOperationException());
var controller = new AccountController(_systemClock.Object, _urlService.Object, _emailSender.Object, _logger.Object, mockUserManager.Object);
var testModel = new UserEmailDto()
{
};
// Act
var result = await controller.PostForgotPasswordAsync(testModel);
// Assert
var objectResult = Assert.IsType <BadRequestObjectResult>(result);
var expected = "An error occurred";
objectResult.Value.Should().BeOfType <string>();
objectResult.Value.Should().BeEquivalentTo(expected);
}
public async Task ResendConfirmEmailMessageAsync_NotFound_WhenRepositoryReturnsNull()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
mockUserManager.Setup(repo => repo.FindByNameAsync(It.IsAny <string>()))
.Returns(Task.FromResult <ApplicationUser>(null));
var controller = new AccountController(_systemClock.Object, _urlService.Object, _emailSender.Object, _logger.Object, mockUserManager.Object);
var testModel = new UserEmailDto()
{
};
// Act
var result = await controller.PostResendConfirmEmailMessageAsync(testModel);
// Assert
var objectResult = Assert.IsType <NotFoundObjectResult>(result);
var expected = "User not found";
objectResult.Value.Should().BeOfType <string>();
objectResult.Value.Should().BeEquivalentTo(expected);
}
public async Task <UserEmailDto> PutUserEmail(int id, UserEmailDto model)
{
return(await _userEmailApiClient.PutUserEmail(id, model));
}
public async Task <UserEmailDto> PostUserEmail(UserEmailDto model)
{
return(await _userEmailApiClient.PostUserEmail(model));
}
