public async Task VerifyEmailAsync([FromBody] EmailVerificationRequest model)
{
var result = await _adminManagementServiceClient.AdminsApi.ConfirmEmailAsync(new VerificationCodeConfirmationRequestModel
{
VerificationCode = model.VerificationCode
});
if (result.Error != VerificationCodeError.None)
{
switch (result.Error)
{
case VerificationCodeError.AlreadyVerified:
_log.Warning(result.Error.ToString());
throw LykkeApiErrorException.BadRequest(
new LykkeApiErrorCode("EmailIsAlreadyVerified", "Email has been already verified"));
case VerificationCodeError.VerificationCodeDoesNotExist:
_log.Warning(result.Error.ToString());
throw LykkeApiErrorException.BadRequest(
new LykkeApiErrorCode(result.Error.ToString(), "Verification code does not exist"));
case VerificationCodeError.VerificationCodeMismatch:
_log.Warning(result.Error.ToString());
throw LykkeApiErrorException.BadRequest(
new LykkeApiErrorCode(result.Error.ToString(), "Verification code mismatch"));
case VerificationCodeError.VerificationCodeExpired:
_log.Warning(result.Error.ToString());
throw LykkeApiErrorException.BadRequest(
new LykkeApiErrorCode(result.Error.ToString(), "Verification code has expired"));
}
}
_log.Info($"Email verification success with code '{model.VerificationCode}'");
}
public ServiceDataWrapper <bool> ConfirmEmail([FromRoute] string id, [FromBody] EmailVerificationRequest request)
{
return(new ServiceDataWrapper <bool>
{
value = _service.ConfirmEmail(id, request.Token).Result
});
}
public async Task <IActionResult> VerifyEmail([FromBody] EmailVerificationRequest request)
{
var user = await _authorizationUtil.GetUser(User);
await _userBusiness.VerifyEmail(request, user);
return(Ok());
}
public ActionResult Verify(string id)
{
try
{
EmailVerificationRequest request = new EmailVerificationRequest();
request.Token = id;
accessController.VerifyUserEmail(request);
}
catch (Exception excp)
{
ViewBag.Error = excp.Message;
}
return(View());
}
public async Task <ActionResult> PostResendUserEmailVerificationLink([FromBody] EmailVerificationRequest emailVerificationRequest)
{
var result = await _authRepository.ResendUserEmailVerificationLink(emailVerificationRequest);
if (result.StatusCode == Utils.Success)
{
var userInfoToReturn = _mapper.Map <UserToReturn>((User)result.ObjectValue);
result.ObjectValue = userInfoToReturn;
return(StatusCode(StatusCodes.Status200OK, result));
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, result));
}
}
public async Task <IActionResult> VerifyEmail([FromBody] EmailVerificationRequest request)
{
var user = await DatabaseContext
.Users
.Where(u => u.EmailVerificationCode == request.Code)
.FirstOrDefaultAsync();
if (user == null)
{
return(BadRequest(400));
}
user.EmailVerificationCode = null;
await DatabaseContext.SaveChangesAsync();
return(Ok());
}
public async Task VerifyEmail(EmailVerificationRequest model, IUser user)
{
if (user.Id != model.UserId)
{
throw new UnauthorizedAccessException();
}
var existing = await _userService.GetById(model.UserId);
if (existing == null)
{
throw new NotFoundException();
}
foreach (var uc in existing.UserClaims)
{
uc.IsClaimed = true;
}
var userClaim = existing.UserClaims.SingleOrDefault(uc =>
uc.ClaimToken == model.VerificationCode &&
uc.UserId == model.UserId
);
existing.EmailVerified = true;
await _userService.Update(existing);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="request"></param>
/// <returns></returns>
public bool ConfirmEmail(string id, EmailVerificationRequest request)
{
return(PutRequest <bool>(_baseUrl + string.Format(ApiRoutes.Identity.ConfirmEmail, id), null, GetHttpContent(request)));
}
public async Task <ReturnResponse> ResendUserEmailVerificationLink(EmailVerificationRequest emailVerificationRequest)
{
if (emailVerificationRequest == null || string.IsNullOrWhiteSpace(emailVerificationRequest.EmailAddress))
{
return(new ReturnResponse()
{
StatusCode = Utils.ObjectNull
});
}
var user = await _userManager.FindByEmailAsync(emailVerificationRequest.EmailAddress);
if (user != null)
{
if (user.EmailConfirmed)
{
return(new ReturnResponse()
{
StatusCode = Utils.EmailAlreadyConfirmed,
StatusMessage = Utils.StatusMessageEmailAlreadyConfirmed
});
}
//SEND MAIL TO USER TO CONFIRM EMAIL
var userTokenVal = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string hashedEmail = GetHashedEmail(user.Email);
string fullToken = userTokenVal + "#" + hashedEmail;
var emailVerificationLink = GetResendUserEmailVerificationLink(fullToken);
if (emailVerificationLink == null)
{
return(new ReturnResponse()
{
StatusCode = Utils.ObjectNull,
StatusMessage = Utils.StatusMessageObjectNull
});
}
var emailSubject = "CONFIRM YOUR EMAIL ADDRESS";
var currentUserName = "";
if (user.UserType == Utils.Customer)
{
currentUserName = (await _dataContext.Customer.Where(c => c.CustomerId == user.UserTypeId).FirstOrDefaultAsync()).FullName;
}
else if (user.UserType == Utils.Administrator)
{
currentUserName = (await _dataContext.Administrator.Where(c => c.AdministratorId == user.UserTypeId).FirstOrDefaultAsync()).FullName;
}
string link = emailVerificationLink;
var emailMessage1 = "";
var emailMessage2 = "Please click the button below to complete your email verification and activate you account.";
string emailBody = _globalRepository.GetMailBodyTemplate(currentUserName, "", link, emailMessage1, emailMessage2, "activation.html");
//SEND MAIL TO CUSTOMER TO VERIFY EMAIL
MailModel mailObj = new MailModel(_configuration.GetValue <string>("MercuryMartEmailAddress"), _configuration.GetValue <string>("MercuryMartEmailName"), user.Email, emailSubject, emailBody);
var response = await _mailRepository.SendMail(mailObj);
if (response.StatusCode.Equals(HttpStatusCode.Accepted))
{
return(new ReturnResponse()
{
StatusCode = Utils.Success,
StatusMessage = "Email Verification Link Sent Successfully!!!",
ObjectValue = user
});
}
else
{
return(new ReturnResponse()
{
StatusCode = Utils.MailFailure,
StatusMessage = Utils.StatusMessageMailFailure
});
}
}
return(new ReturnResponse()
{
StatusCode = Utils.NotFound,
StatusMessage = Utils.StatusMessageNotFound
});
}
