/// <summary>
/// Method to validate verificationDto sent in POST request.
/// </summary>
/// <param name="verificationDto">verificationDto contains information related to verification procedure.</param>
/// <returns>Pair of {status:boolean,ApiKeyName/verificationDto} </returns>
public static Pair ValidateVerificationDto(VerificationDto verificationDto)
{
var returnSuccessValidation = new Pair {
First = true, Second = verificationDto
};
if (string.IsNullOrWhiteSpace(verificationDto.VerificationCode) || !verificationDto.VerificationCode.Length.Equals(RequestValidationConstant.VerficationCodeLength))
{
return new Pair {
First = false, Second = ApiRequestKeys.VerificationCode
}
}
;
if (string.IsNullOrWhiteSpace(verificationDto.Handle))
{
return new Pair {
First = false, Second = ApiRequestKeys.Handle
}
}
;
if (string.IsNullOrWhiteSpace(verificationDto.Password))
{
return new Pair {
First = false, Second = ApiRequestKeys.Password
}
}
;
return(returnSuccessValidation);
}
public async Task SetVerificationUsed(BizCode bizCode, string code, string to)
{
VerificationDto result = null;
var client = _clientFactory.CreateClient("arcanestars");
var jsonStr = JsonConvert.SerializeObject(new VerificationDto {
BizCode = bizCode, To = to, Code = code
});
var content = new StringContent(jsonStr);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");//x-www-form-urlencoded
content.Headers.Add(_config.VerificationServiceApiKey, _config.VerificationServiceApiValue);
var response = await client.PatchAsync($"{_config.VerificationServiceRootUrl}api/verification/v1", content);
var responseContent = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
result = JsonConvert.DeserializeObject <VerificationDto>(responseContent);
}
else
{
result = null;
}
}
public async Task <IResult <GenericResponse> > VerifyCustomer(VerificationDto verificationData)
{
var user = await _userService.GetUserBasedOnEmail(verificationData.Email);
if (user.IsNone)
{
return(await Response <GenericResponse> .GetErrorResponseMessage("No Rrcord found with this email address"));
}
var alwaysAUser = user.Always();
if (!(new Helper().TokenToHash(verificationData.VerificationCode) == alwaysAUser.VerificationCode))
{
return(await Response <GenericResponse> .GetErrorResponseMessage("Wrong verification code"));
}
alwaysAUser.Verified = true;
alwaysAUser.ModifiedOn = DateTime.UtcNow;
return
(_userService.UpdateUser(alwaysAUser, alwaysAUser.Id)
? await Task <IResult <GenericResponse> > .Factory.StartNew(
() => Response <GenericResponse> .SuccessResponese(
"User Is Verified"
))
: await Response <GenericResponse> .GetErrorResponseMessage("Something Went Wrong. Please Try Again Later"));
}
public async Task <IActionResult> VerifyCustomer(VerificationDto verificationData)
{
return((await _accountService.VerifyCustomer(verificationData))
.Match <IActionResult>(
Ok,
BadRequest
));
}
public async Task <ActionResult> SMSVerification(VerificationDto verificationDto)
{
var user = await _userManager.FindByNameAsync(verificationDto.PhoneNumber);
bool isValid = await _userManager.VerifyUserTokenAsync(user, "Default", "passwordless-auth", verificationDto.AuthToken);
if (!isValid)
{
return(Unauthorized("not authorized!"));
}
await _userManager.UpdateSecurityStampAsync(user);
var userDto = MapAppUserToUserDto(user);
return(Ok(userDto.Result));
}
/// <summary>
/// User service to verify a new user. The method check the verification code in database saved in database against the verificationCode sent by user.
/// </summary>
/// <param name="verificationDto">verificationDto contains verification details of the user</param>
/// <returns>ResponseModel is the model sent associated to the verification process.</returns>
public ResponseModel VerifyUser(VerificationDto verificationDto)
{
var validationStatus = ValidateRequest.ValidateVerificationDto(verificationDto);
if (!(bool)validationStatus.First)
{
return(ReturnStatements.BadRequestResponse(validationStatus.Second));
}
verificationDto = validationStatus.Second;
using (var unitOfWork = new UnitOfWork())
{
var userList = unitOfWork.Users.FindOnConstraint(m => m.Handle.Equals(verificationDto.Handle), prop => prop.UserPasswords).ToList();
//If userList.Count is 0 then user does not exist. Zero index is used in this method because initially there is only one user and one password.
if (userList.Count.Equals(0))
{
return(ReturnStatements.FailedResponse(Strings.UserDoNotExist));
}
var userPassword = userList[0].UserPasswords.ToList()[0];
if (!userPassword.Password.Equals(verificationDto.Password))
{
return(ReturnStatements.FailedResponse(Strings.PasswordMismatch));
}
if (userList[0].VerificationCode.Equals(verificationDto.VerificationCode))
{
userList[0].IsVerified = true;
unitOfWork.Users.Update(userList[0]);
var saveResponse = unitOfWork.Complete();
if (saveResponse.Equals(Integers.UnsuccessfullDatabaseSave))
{
return(ReturnStatements.FailedResponse(Strings.UnsuccessfullVerification));
}
return(ReturnStatements.SuccessResponse(Strings.SuccessfullVerification));
}
return(ReturnStatements.FailedResponse(Strings.VerificationCodeMismatch));
}
}
public async Task <VerificationDto> GetVerification(BizCode bizCode, string to)
{
VerificationDto result = null;
var client = _clientFactory.CreateClient("arcanestars");
client.DefaultRequestHeaders.Add(_config.VerificationServiceApiKey, _config.VerificationServiceApiValue);
var response = await client.GetAsync($"{_config.VerificationServiceRootUrl}api/verification/v1/{(int)bizCode}/{to}");
var contentJson = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
result = JsonConvert.DeserializeObject <VerificationDto>(contentJson);
}
else
{
result = null;
}
return(result);
}
public HttpResponseMessage Verify(VerificationDto verificationDto)
{
var result = _services.VerifyUser(verificationDto);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
