public async Task ConfirmEmail_WhenUserNotFound_ReturnsUserNotFoundResponses()
{
var request = new EmailConfirmationRequest()
{
Code = "emailCode"
};
var httpResponse = await GetAsync(AuthControllerRoutes.ConfirmEmail + "?" + request.ToQueryString());
httpResponse.EnsureSuccessStatusCode();
var response = await httpResponse.BodyAs <ApiResponse>();
response.CheckValidationException(1);
request = new EmailConfirmationRequest()
{
Code = "emailCode"
};
httpResponse = await GetAsync(AuthControllerRoutes.ConfirmEmail + "?" + request.ToQueryString());
httpResponse.EnsureSuccessStatusCode();
response = await httpResponse.BodyAs <ApiResponse>();
response.CheckValidationException(1);
request = new EmailConfirmationRequest();
httpResponse = await GetAsync(AuthControllerRoutes.ConfirmEmail + "?" + request.ToQueryString());
httpResponse.EnsureSuccessStatusCode();
response = await httpResponse.BodyAs <ApiResponse>();
response.CheckValidationException(3);
}
public async Task <IActionResult> EmailConfirmation(string id, EmailConfirmationRequest confirmationRequest)
{
if (id != confirmationRequest.UserId)
{
return(BadRequest());
}
var user = await _userManager.FindByIdAsync(confirmationRequest.UserId);
if (user == null)
{
return(NotFound());
}
try
{
var result = await _userManager.ConfirmEmailAsync(user, confirmationRequest.Code);
return(Ok(result.Succeeded));
}
catch (DbUpdateConcurrencyException) when(!_userManager.Users.AsNoTracking().Any(u => u.Id == id))
{
return(NotFound());
}
}
public async Task <ApiResponse> ConfirmEmail([FromBody] EmailConfirmationRequest request)
{
if (request == null)
{
return(ApiResponse.Failed());
}
return(await _userIdentityService.ConfirmEmailAsync(request));
}
public async Task <IActionResult> GetEmailPriorityCode(EmailConfirmationRequest model)
{
var result = await _emailConfirmationService.GetPriorityCode(model.Email, model.PartnerId);
if (result == null)
{
return(BadRequest("Code not found."));
}
var response = new EmailVerificationCode(result.Code, result.CreationDateTime, result.ExpirationDate);
return(Ok(response));
}
/// <summary> Creates a confirmation token that will be used to verify a user's email adress and stores it in the database.</summary>
/// <param name="userId"> The user ascociated with the email confirmation.</param>
/// <returns> Token that will be sent to the user's email adress to verify their email adress.</returns>
public async Task <string> GenerateEmailConfiramtionTokenAsync(long userId)
{
Guid token = new Guid();
var emailRequest = new EmailConfirmationRequest()
{
UserId = userId,
ConfirmationToken = token,
ExpirationDate = DateTime.UtcNow.AddDays(7)
};
await _context.EmailConfirmationRequests.AddAsync(emailRequest);
await _context.SaveChangesAsync();
return(token.ToString());
}
public async Task ConfirmEmailAsync_WhenUserNotFound_ShouldReturnUserNotFound()
{
var request = new EmailConfirmationRequest()
{
Code = "code",
UserId = Guid.NewGuid(),
};
_mockUserManger.Setup(e => e.FindByIdAsync(request.UserId.ToString()))
.ReturnsAsync((User)null);
var response = await sut.ConfirmEmailAsync(request);
response.IsSuccess.Should().BeFalse();
response.ResponseException !.ErrorCode.Should().Be(ErrorCode.UserNotFound);
response.ResponseException.ErrorMessage.Should().Be(ErrorCode.UserNotFound.GetDescription());
}
public async Task ConfirmEmail_WhenCodeNotValid_ReturnsUserNotFoundResponses()
{
var context = GetService <TimeTrackingIdentityDbContext>();
var userFromDatabase = await context.Users.FirstOrDefaultAsync();
var request = new EmailConfirmationRequest()
{
UserId = userFromDatabase.Id,
Code = "emailCode"
};
var httpResponse = await GetAsync(AuthControllerRoutes.ConfirmEmail + "?" + request.ToQueryString());
httpResponse.EnsureSuccessStatusCode();
var response = await httpResponse.BodyAs <ApiResponse>();
response.ResponseException !.ErrorCode.Should().Be(ErrorCode.EmailConfirmationFailed);
response.ResponseException !.ErrorMessage.Should().Be(ErrorCode.EmailConfirmationFailed.GetDescription());
}
public async Task <IActionResult> VerifyEmail([FromQuery] EmailConfirmationRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new EmailConfirmationResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
}));
}
var emailConfirmationResponse = await _identityService.ConfirmEmailAsync(request.Email, request.Token);
if (!emailConfirmationResponse.Success)
{
return(BadRequest(emailConfirmationResponse.Errors));
}
return(Ok(emailConfirmationResponse));
}
public async Task <ApiResponse> ConfirmEmailAsync(EmailConfirmationRequest request)
{
var userFoundedResponse = await FindUserByIdAsync(request.UserId);
if (!userFoundedResponse.IsSuccess)
{
return(userFoundedResponse);
}
var result = await _userManager.ConfirmEmailAsync(userFoundedResponse.Data, request.Code);
if (result.Succeeded)
{
var addToRoleAsync = await _userManager.AddToRoleAsync(userFoundedResponse.Data,
AuthorizationData.DefaultRole.ToString());
if (!addToRoleAsync.Succeeded)
{
_logger.LogError("Failed to add user to to role with reason {0}",
addToRoleAsync.ToString());
return(new ApiResponse(
new ApiError()
{
ErrorCode = ErrorCode.AddUserToRoleFailed,
ErrorMessage = ErrorCode.AddUserToRoleFailed.GetDescription(),
}));
}
return(ApiResponse.Success());
}
_logger.LogWarning("Email confirmation failed for user with id {0} by reason {1}",
request.UserId, result.Errors.ToString());
return(new ApiResponse()
{
ResponseException = new ApiError()
{
ErrorCode = ErrorCode.EmailConfirmationFailed,
ErrorMessage = ErrorCode.EmailConfirmationFailed.GetDescription(),
},
StatusCode = 400,
IsSuccess = false,
});
}
public async Task ConfirmEmailAsync_WhenConfirmEmailFailed_ShouldReturnEmailConfirmationFailed()
{
var request = new EmailConfirmationRequest()
{
Code = "code",
UserId = Guid.NewGuid(),
};
_mockUserManger.Setup(e => e.FindByIdAsync(request.UserId.ToString()))
.ReturnsAsync((new User()));
_mockUserManger.Setup(e => e.ConfirmEmailAsync(It.IsAny <User>(), request.Code))
.ReturnsAsync(IdentityResult.Failed());
var response = await sut.ConfirmEmailAsync(request);
response.IsSuccess.Should().BeFalse();
response.ResponseException !.ErrorCode.Should().Be(ErrorCode.EmailConfirmationFailed);
response.ResponseException.ErrorMessage.Should().Be(ErrorCode.EmailConfirmationFailed.GetDescription());
}
public async Task <IActionResult> EmailConfirmation([FromBody] EmailConfirmationRequest confirmationRequest)
{
try
{
var user = await _userManager.FindByIdAsync(confirmationRequest.UserId);
if (user == null)
{
throw new Exception("User not found");
}
var result = await _userManager.ConfirmEmailAsync(user, confirmationRequest.Code);
return(Ok(result.Succeeded));
} catch (Exception ex)
{
_logger.LogError($"Email confirmation error: {ex.Message} - UserID: {confirmationRequest.UserId} - Code: {confirmationRequest.Code}");
return(Ok(false));
}
}
public IActionResult ConfirmEmail(EmailConfirmationRequest model)
{
if (string.IsNullOrEmpty(model.UserId) || model.UserId.Length < 2)
{
return(View("ConfirmEmailFail", null));
}
if (string.IsNullOrEmpty(model.Token) || model.Token.Length < 2)
{
return(View("ConfirmEmailFail", null));
}
var response = WebAPI <AuthenticationResult, EmailConfirmationRequest> .Consume(SharedEndpoints.ConfirmEmail, model, "");
if (!response.IsSuccessful)
{
return(View("ConfirmEmailFail", response.DebugMessage));
}
return(View());
}
public async Task ConfirmEmailAsync_WhenAddToRoleSuccess_ShouldReturnSuccessResponse()
{
var request = new EmailConfirmationRequest()
{
Code = "code",
UserId = Guid.NewGuid(),
};
var user = new User();
_mockUserManger.Setup(e => e.FindByIdAsync(request.UserId.ToString()))
.ReturnsAsync(user);
_mockUserManger.Setup(e => e.ConfirmEmailAsync(It.IsAny <User>(), request.Code))
.ReturnsAsync(IdentityResult.Success);
_mockUserManger.Setup(e => e.AddToRoleAsync(user, AuthorizationData.DefaultRole.ToString()))
.ReturnsAsync(IdentityResult.Success);
var response = await sut.ConfirmEmailAsync(request);
response.IsSuccess.Should().BeTrue();
response.StatusCode.Should().Be(200);
}
public async Task <IActionResult> Delete([FromBody] EmailConfirmationRequest model)
{
await _emailConfirmationService.DeleteCodes(model.Email, model.PartnerId);
return(Ok());
}
