public bool ResendMail(string Email, ref string msg)
{
try
{
ResendEmailRequest paraBody = new ResendEmailRequest();
paraBody.Email = Email;
NSLog.Logger.Info("ResendMail Request: ", paraBody);
//====================
var result = (NSApiResponse)ApiResponse.Post <NSApiResponse>(Commons.ClientSideAccountToResendEmail, null, paraBody);
if (result != null)
{
if (result.Success)
{
return(true);
}
else
{
msg = result.Message;
//NSLog.Logger.Info("AccountRegisterCreate", result.Message);
return(false);
}
}
else
{
return(false);
}
NSLog.Logger.Info("ResendMail Result", result);
}
catch (Exception e)
{
NSLog.Logger.Error("ResendMail_Fail", e);
return(false);
}
}
public async void ResendEmail_Returns_Success(ResendEmailRequest req, string description)
{
//Arrange
var user = new AppUser
{
Email = req.Email,
UserName = req.UserName,
RefreshTokens = new List <RefreshToken>(),
Id = Guid.NewGuid().ToString()
};
fakeUserManager.Setup(x => x.FindByEmailAsync(It.IsAny <string>()))
.Returns(Task.FromResult(user));
fakeUserManager.Setup(x => x.FindByNameAsync(It.IsAny <string>()))
.Returns(Task.FromResult(user));
fakeUserManager.Setup(x => x.CreateAsync(It.IsAny <AppUser>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success).Callback <AppUser, string>((x, y) => context.Users.Add(new AppUser
{
Email = x.Email
}));
// create url helper mock
Type t = typeof(UserServiceTest);
var httpContext = new Mock <HttpContext>().Object;
actionContextAccessor.Setup(x => x.ActionContext).Returns(new ActionContext(
httpContext,
new Microsoft.AspNetCore.Routing.RouteData(),
new ControllerActionDescriptor()
{
MethodInfo = t.GetMethod(nameof(UserServiceTest.TestRegister_Return_OkResult))
}));
mockUrlHelper = new Mock <IUrlHelper>();
mockUrlHelperFactory.Setup(x => x.GetUrlHelper(It.IsAny <ActionContext>())).Returns(mockUrlHelper.Object);
mockUrlHelper.SetupGet(h => h.ActionContext).Returns(actionContextAccessor.Object.ActionContext);
UrlActionContext actual = null;
mockUrlHelper.Setup(h => h.Action(It.IsAny <UrlActionContext>()))
.Callback((UrlActionContext context) => actual = context);
fakeUserManager.Setup(x => x.GenerateEmailConfirmationTokenAsync(It.IsAny <AppUser>())).ReturnsAsync("");
mockEmailSender.Setup(x => x.SendEmailAsync(It.IsAny <Message>())).Returns(() => Task.FromResult(""));
//Act
var result = await _userService.Object.ResendEmail(req);
//Assert
Assert.IsType <OkObjectResult>(result);
}
public async Task ResendVerificationEmail_WhenUserNotFoundById_ReturnsUserNotFound()
{
var request = new ResendEmailRequest()
{
Email = "*****@*****.**"
};
var httpResponse = await PostAsync(AuthControllerRoutes.ResendEmailVerificationCode, request);
httpResponse.EnsureSuccessStatusCode();
var response = await httpResponse.BodyAs <ApiResponse>();
response.ResponseException !.ErrorCode.Should().Be(ErrorCode.UserNotFound);
response.ResponseException !.ErrorMessage.Should().Be(ErrorCode.UserNotFound.GetDescription());
}
public async Task ResendVerificationEmail_WhenUserFoundByEmail_ReturnsSuccessResponse()
{
var request = new ResendEmailRequest()
{
Email = "*****@*****.**"
};
var httpResponse = await PostAsync(AuthControllerRoutes.ResendEmailVerificationCode, request);
httpResponse.EnsureSuccessStatusCode();
var response = await httpResponse.BodyAs <ApiResponse>();
response.StatusCode.Should().Be(200);
response.IsSuccess.Should().BeTrue();
}
public async Task ResentEmailAsync_WhenFailedToFindUSerByEmail_ShouldReturnUserNotFound()
{
var request = new ResendEmailRequest()
{
Email = "email",
};
_mockUserManger.Setup(e => e.FindByEmailAsync(request.Email))
.ReturnsAsync((User)null);
var response = await sut.ResentEmailAsync(request);
response.IsSuccess.Should().BeFalse();
response.ResponseException !.ErrorCode.Should().Be(ErrorCode.UserNotFound);
response.ResponseException.ErrorMessage.Should().Be(ErrorCode.UserNotFound.GetDescription());
}
// Resend Confirmation Email
public async Task<HttpResponseMessage> ResendEmail(ResendEmailRequest model)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
try
{
string guid = _userService.GetGuidByEmail(model.Id);
await _emailService.SendEmailConfirmation(model.Email, guid);
return Request.CreateResponse(HttpStatusCode.OK);
}
catch (Exception ex)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
}
}
public async Task <ApiResponse> ResentEmailAsync(ResendEmailRequest request)
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
return(new ApiResponse <User>(new ApiError()
{
ErrorCode = ErrorCode.UserNotFound,
ErrorMessage = ErrorCode.UserNotFound.GetDescription(),
}));
}
return(await _emailHelperService.SendEmailConfirmationEmail(new EmailSendRequest()
{
ClientUrl = request.ClientUrl,
User = user,
}));
}
public async Task ReSendEmail([FromBody] ResendEmailRequest request)
{
var userId = _authService.GetUserIdByToken(request.Token);
var user = await _userService.GetByIdAsync(userId.Value);
if (user == null)
{
throw new AppErrorException(new AppError(ErrorCode.UserNotFound));
}
if (user.IsEmailConfirm)
{
throw new AppErrorException(new AppError(ErrorCode.RegistrationIsAlreadyConfirmed));
}
var token = _mailTokenService.EncryptToken(user.Email);
var model = new ConfirmRegisterEmailModel {
UserId = user.Id, Email = user.Email, Token = token
};
await _queueProvider.SendMessageAsync(model.ToJson());
}
public async Task <ApiResponse> ResendVerificationEmail([FromBody] ResendEmailRequest request)
{
return(await _userIdentityService.ResentEmailAsync(request));
}
