public override async Task <VerifyEmailReply> VerifyEmail(VerifyEmailRequest request, ServerCallContext context)
{
AppUser user = await _userManager.FindByIdAsync(request.UserId);
if (user == null)
{
return(new VerifyEmailReply {
Success = false
});
}
string code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(request.Code));
IdentityResult result = await _userManager.ConfirmEmailAsync(user, code);
if (result.Succeeded)
{
return(new VerifyEmailReply {
Success = true
});
}
return(new VerifyEmailReply {
Success = false
});
}
public override async Task <VerifyResponse> VerifyEmail(VerifyEmailRequest request, ServerCallContext context)
{
var token = await _registrationTokenService.GetByOriginalTokenAsync(request.Token);
if (token == null || string.IsNullOrEmpty(request.Code) ||
token.ExpirationDate <= DateTime.UtcNow ||
token.EmailHash != request.Email.ToSha256().ToBase64() ||
token.LastCodeHash != request.Code.ToSha256().ToBase64())
{
return(new VerifyResponse()
{
Result = new VerifyResponse.Types.VerifyPayload()
{
Passed = false
}
});
}
token.EmailVerified = true;
await _registrationTokenService.SaveAsync(token);
return(new VerifyResponse()
{
Result = new VerifyResponse.Types.VerifyPayload()
{
Passed = true
}
});
}
/**
* Set user address.
*/
private async Task <APIGatewayProxyResponse> VerifyEmail(IDataStores dataStores,
JObject requestBody)
{
Debug.Untested();
Debug.AssertValid(dataStores);
Debug.AssertValidOrNull(requestBody);
try {
// Log call
LoggingHelper.LogMessage($"UserIdentityService::VerifyEmail()");
// Get the NoSQL DB client
AmazonDynamoDBClient dbClient = (AmazonDynamoDBClient)dataStores.GetNoSQLDataStore().GetDBClient();
Debug.AssertValid(dbClient);
// Check inputs
VerifyEmailRequest verifyEmailRequest = UserIdentityService_VerifyEmail_LogicLayer.CheckValidVerifyEmailRequest(requestBody);
Debug.AssertValid(verifyEmailRequest);
// Perform logic
await UserIdentityService_VerifyEmail_LogicLayer.VerifyEmail(dbClient, verifyEmailRequest);
// Respond
return(new APIGatewayProxyResponse {
StatusCode = APIHelper.STATUS_CODE_NO_CONTENT
});
} catch (Exception exception) {
Debug.Tested();
return(APIHelper.ResponseFromException(exception));
}
}
public IActionResult VerifyEmail(VerifyEmailRequest model)
{
try
{
bool isCodeValid = _authService.VerifyCode(model.Token, model.UserId);
if (isCodeValid)
{
UserVerify userVerify = new UserVerify
{
Message = "Verification successful, you can now login"
};
return(Ok(userVerify));
}
else
{
// return statusCode not allowed with a message
return(StatusCode(StatusCodes.Status403Forbidden, "Verification code is invalid"));
}
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public async Task <ActionResult> VerifyEmail([FromBody] VerifyEmailRequest verifyEmailRequest)
{
try
{
var mainResponse = await CheckTenantDetails();
if (mainResponse.Status == false)
{
_json = Mapper.convert <Tenant>(mainResponse);
return(BadRequest(_json));
}
verifyEmailRequest.Host = _host;
verifyEmailRequest.APIKey = mainResponse.tenantResponse.APIKey;
var userResponse = await _userService.VerifyEmail(verifyEmailRequest);
userResponse.Status = true;
userResponse.Message = Constants.EMAIL_VERIFICATION;
_json = Mapper.convert <UserResponse>(_response);
return(new OkObjectResult(_json));
}
catch (Exception ex)
{
_response.Message = ex.Message;
_response.Status = false;
_json = Mapper.convert <UserResponse>(_response);
return(BadRequest(_json));
}
}
public async Task <IActionResult> VerifyEmail([FromBody] VerifyEmailRequest request)
{
var verifyOutput = await _subscriberAppService.CheckEmailVerification(new CheckEmailVerificationInput
{
EmailAddress = request.EmailAddress,
VerifyCode = request.VerifyCode
});
if (verifyOutput.HasError)
{
return(StatusCode(500, new ApiResponse(500, verifyOutput.ErrorMessage)));
}
var updateOut = await _subscriberAppService.Update(new UpdateSubscriberInput
{
Id = verifyOutput.SubscriberId,
EmailAddressVerified = true
});
if (updateOut.HasError)
{
return(StatusCode(500, new ApiResponse(500, updateOut.ErrorMessage)));
}
return(Ok(new ApiOkResponse(true)));
}
public override async Task <VerifyResponse> VerifyEmail(VerifyEmailRequest request, ServerCallContext context)
{
var result = new VerifyResponse();
var response = await _walletApiV1Client.VerifyEmailAsync(new VerifyEmailRequestModel
{
Email = request.Email,
Code = request.Code,
Token = request.Token
});
if (response.Result != null)
{
result.Body = new VerifyResponse.Types.Body {
Passed = response.Result.Passed
};
}
if (response.Error != null)
{
result.Error = response.Error.ToApiError();
}
return(result);
}
public IActionResult VerifyEmail([FromBody] VerifyEmailRequest verifyEmailRequest)
{
if (verifyEmailRequest == null)
{
return(BadRequest());
}
var verificationCodeCacheKey = VerificationCodeCacheKey(verifyEmailRequest.EmailAddress);
if (MemoryCache.TryGetValue(verificationCodeCacheKey, out string verificationCode))
{
if (verificationCode == verifyEmailRequest.VerificationCode)
{
// authentication successful.
ExpireVerificationCode(verifyEmailRequest.EmailAddress);
var token = CreateVerificationToken(verifyEmailRequest.EmailAddress, out string sessionId);
MemoryCache.Set("SessionId:" + sessionId, true);
return(Ok(token));
}
IncrementFailedVerificationAttemptsOrExpire(verifyEmailRequest.EmailAddress);
}
return(Unauthorized());
}
public IActionResult VerifyEmail(VerifyEmailRequest model)
{
this.accountService.VerifyEmail(model.Token);
this.logger.LogInformation("Verification successful");
return(this.Ok(new { message = "Verification successful, you can now login" }));
}
/*
* Method to check if email is validated
*/
public VerifyEmailResponse CheckifUserIsVerified(VerifyEmailRequest verifyEmailRequest)
{
//check if user has validate email
var userIsVerified = _ucOnlinePortalContext.LoginInfos.Where(x => x.StudId == verifyEmailRequest.id_number || x.Email == verifyEmailRequest.email).FirstOrDefault();
return(new VerifyEmailResponse {
is_verified = (short)userIsVerified.IsVerified
});
}
public IActionResult VerifyEmail([FromBody] VerifyEmailRequest jwtToken)
{
bool result = _userService.VerifyEmail(jwtToken.Token);
if (result)
{
return(Ok(new { message = "Verification successful, you can now login" }));
}
return(BadRequest(new { message = "Invalid access token" }));
}
public async Task <ActionResult> VerifyEmail(VerifyEmailRequest request, CancellationToken ct)
{
var isVerified = await _emailVerificationService.VerifyAsync(request.TokenId, request.Code, ct);
if (!isVerified)
{
return(BadRequest("Invalid code"));
}
return(View("~/OAuth/Views/VerifyEmail.cshtml"));
}
public void ConfirmEmail_ChangeValueOfIsEmailConfirmed_CompareStatus()
{
var request = new VerifyEmailRequest();
request.Username = ""; //Enter "Receiver's" email address here
var expectedStatus = "True";
var response = _userService.VerifyEmail(request);
var IsEmailConfirmed = (response.Result.IsEmailConfirmed).ToString();
Assert.Matches(expectedStatus, IsEmailConfirmed);
}
public IActionResult VerifyPaswordToken([FromBody] VerifyEmailRequest token)
{
bool result = _userService.VerifyPasswordToken(token.Token);
string email = TokenManager.ValidateJwtToken(token.Token, "email");
if (result)
{
return(Ok(new { email = email }));
}
return(BadRequest(new { message = "Token wygasł lub jest nieprawidłowy" }));
}
public async Task <IActionResult> VerifyEmailAsync([FromQuery] VerifyEmailRequest request)
{
await _accountService.VerifyEmailAsync(request);
var response = new VerifyEmailResponseModel()
{
RedirectUrl = request.RedirectUrl
};
return(Ok(response));
}
public async Task <ActionResult <UserResponse> > EmailVerification(int id, VerifyEmailRequest request)
{
var verificationResponse = await _userService.VerifyEmail(id, request.Token);
if (!verificationResponse.Success)
{
return(BadRequest(verificationResponse.Errors));
}
return(verificationResponse.Object);
}
public IActionResult VerifyEmail(VerifyEmailRequest model)
{
var account = _repository.Account.VerifyEmail(model.Token);
if (account == null)
{
throw new AppException("Verification failed");
}
_repository.Account.SaveVerificationToken(model.Token, ref account);
_logger.LogInfo($"Successfully verified account.");
return(Ok(new { message = "Verification successful, you can now login" }));
}
public async Task <UserResponse> VerifyEmail(VerifyEmailRequest verifyEmailRequest)
{
var userDetails = await _userRepository.verifyEmail(verifyEmailRequest);
if (userDetails == null)
{
throw new Exception(Constants.NO_RECORD_FOUND);
}
var userResponse = _mapper.Map <UserResponse>(userDetails);
return(userResponse);
}
public IActionResult VerifyEmail(VerifyEmailRequest model)
{
try
{
accountService.VerifyEmail(model.Token);
return(Ok(new { message = "Verification successful, you can now login" }));
}
catch (Exception ex)
{
return(Forbid(ex.Message));
}
}
public async Task <bool> VerifyEmail(VerifyEmailRequest verifyEmail)
{
var user = await _userManager.FindByEmailAsync(verifyEmail.Email);
if (user == null)
{
return(false);
}
var result = await _userManager.ConfirmEmailAsync(user, verifyEmail.Token);
return(result.Succeeded);
}
public async Task VerifyEmailAsync(VerifyEmailRequest request)
{
Account account = _accountsRepository.FindBy(a => a.VerifyEmailToken == request.Token).FirstOrDefault();
if (account == null)
{
throw new Exception("Account does not exist!");
}
if (account.IsEmailVerified)
{
throw new Exception("Account has been verified already!");
}
account.VerifyEmail();
await _unitOfWork.SaveChangesAsync();
}
public async Task <IActionResult> VerifyEmail([FromQuery] VerifyEmailRequest verifyEmailRequest)
{
var user = await _userManager.FindByIdAsync(verifyEmailRequest.UserId);
if (user == null)
{
return(BadRequest(new { Error = "User doesn't exist :( " }));
}
var result = await _userManager.ConfirmEmailAsync(user, verifyEmailRequest.Code);
if (!result.Succeeded)
{
return(BadRequest(new { Error = "Error during confirmation user email." }));
}
return(Ok(new { Message = "User email confirmated successfull" }));
}
public async Task <User> verifyEmail(VerifyEmailRequest verifyEmailRequest)
{
if (await checkUserEmailExist(verifyEmailRequest.Username) == false)
{
return(null);
}
User user = new User();
string query = "select * from users where username=@username";
user = await GetAsync(query, new { username = verifyEmailRequest.Username });
user.IsEmailConfirmed = true;
user.ModifiedBy = verifyEmailRequest.Username;
user.ModifiedOn = DateTime.UtcNow;
await UpdateAsync(user);
return(user);
}
public async Task <ActionResult> Verify([FromQuery] VerifyEmailRequest req)
{
try
{
string token = req.Token;
User u = this._db.User.Where(user => user.EmailValidationToken == token).FirstOrDefault();
if (u == null || u == default)
{
return(Unauthorized());
}
else
{
u.ValidatedEmail = true;
_ = this._db.SaveChangesAsync().ConfigureAwait(false);
return(Redirect("/"));
}
} catch
{
return(StatusCode(500, "Error"));
}
}
public async Task <IActionResult> CheckIfEmailIsValidated([FromBody] VerifyEmailRequest request)
{
//Check if required fields are present
if (!ModelState.IsValid)
{
return(Ok(new VerifyEmailResponse {
is_verified = 0
}));
}
//Convert response object to DTO Objects
var serialized_req = Newtonsoft.Json.JsonConvert.SerializeObject(request);
var converted_req = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.Request.VerifyEmailRequest>(serialized_req);
//await result from function CheckifUserIsVerified
var result = await Task.FromResult(_loginManagement.CheckifUserIsVerified(converted_req));
//return notification reponse
return(Ok(new VerifyEmailResponse {
is_verified = result.is_verified
}));
}
public IActionResult VerifyEmail(VerifyEmailRequest model)
{
_accountService.VerifyEmail(model.Token);
return(Ok(new { message = "Verification successful, you can now login" }));
}
public async Task <IActionResult> VerifyEmail([FromQuery] VerifyEmailRequest request)
{
await _accountService.VerifyEmailAsync(request);
return(Redirect(request.RedirectUrl));
}
public async Task <IActionResult> VerifyEmail([FromQuery] VerifyEmailRequest model)
{
await _accountService.VerifyEmail(model.Token);
return(Ok(new { message = "Verification successful, you can now login" }));//redirect to http://localhost:3000/login
}
public IActionResult VerifyEmail([FromBody] VerifyEmailRequest verifyEmailRequest)
{
Logger.Debug("Request: {0}", Framework.Common.SerializeJson.ToObject(verifyEmailRequest));
DateTime dateRequest = DateTime.Now;
var response = new IResponse <VerifyEmailResponse>();
string correlationId = string.Empty;
try
{
#region Authorization Usuario y Contraseña
if (string.IsNullOrEmpty(Request.Headers["Authorization"]))
{
var validate = Models.Response.Error(null, "NotAuthenticated");
response.Data = null;
response.Message = validate.Message;
response.State = validate.State;
return(Unauthorized(response));
}
AuthenticationHeaderValue authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
var credentials = Encoding.UTF8.GetString(Convert.FromBase64String(authHeader.Parameter)).Split(':');
correlationId = Request.Headers["Correlation-Id"].ToString();
Core.Entity.User user = new Core.Entity.User()
{
Public = verifyEmailRequest.PublicToken,
UserName = credentials[0],
Password = credentials[1]
};
var userAuthenticate = _user.Authenticate(user);
if (userAuthenticate.Data == null)
{
var validate = Models.Response.Error("NotAuthenticated");
response.Data = null;
response.Message = validate.Message;
response.State = validate.State;
return(Unauthorized(response));
}
Core.Entity.UserPolicy userPolicy = new Core.Entity.UserPolicy()
{
AppUserId = verifyEmailRequest.AppUserId,
IdUser = ((Core.Entity.User)userAuthenticate.Data).Id
};
Core.Entity.Policy policy = new Core.Entity.Policy()
{
Name = Request.Path.Value
};
var userPolicyAuthorize = _userPolicy.Authorize(userPolicy, policy);
if (userPolicyAuthorize.Data == null)
{
var validate = Models.Response.Error("NotUnauthorized");
response.Data = null;
response.Message = validate.Message;
response.State = validate.State;
return(Unauthorized(response));
}
#endregion
var verifiedEmail = _client.UpdateByVerifyEmmail(verifyEmailRequest.TokenEmailVerify, verifyEmailRequest.AppUserId);
if (!(Convert.ToInt32(verifiedEmail.Data) > 0))
{
response.Data = null;
response.Message = verifiedEmail.Message;
response.State = verifiedEmail.State;
return(BadRequest(response));
}
response.Data = new VerifyEmailResponse
{
TokenEmailVerify = verifyEmailRequest.TokenEmailVerify,
Verify = true
};
response.Message = Models.Response.CommentMenssage("VerifyEmailComplete");
response.State = "000";
return(Ok(response));
}
catch (Exception ex)
{
Logger.Error("Message: {0}; Exception: {1}", ex.Message, Framework.Common.SerializeJson.ToObject(ex));
response.Data = null;
response.Message = "Error General";
response.State = "099";
return(BadRequest(response));
}
finally
{
DateTime dateResponse = DateTime.Now;
Core.Entity.ConsumptionHistory consumptionHistory = new Core.Entity.ConsumptionHistory
{
ApiName = Request.Path.Value,
Host = Dns.GetHostName() + ":" + Request.Host.Port,
CorrelationId = correlationId,
AppUserId = verifyEmailRequest.AppUserId,
Request = Framework.Common.SerializeJson.ToObject(verifyEmailRequest),
DateRequest = dateRequest,
Response = Framework.Common.SerializeJson.ToObject(response),
DateResponse = dateResponse,
CodeResponse = response.State
};
_consumptionHistory.Insert(consumptionHistory);
Logger.Debug("Request: {0} Response: {1}", verifyEmailRequest, response);
}
}
public IActionResult VerifyEmail(VerifyEmailRequest model)
{
_accountService.VerifyEmail(model.Token);
return(Ok(new { message = "Верификация прошла успешно, можете войти в аккаунт" }));
}
public HttpResponseMessage SendComfirmEmail(VerifyEmailRequest model)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
BaseResponse response = null;
response = new SuccessResponse();
HttpStatusCode code = HttpStatusCode.OK;
ApplicationUser userVerification = _userService.GetUser(model.Email);
if (userVerification == null)
{
response = new ErrorResponse("Cannot find a user with that email.");
code = HttpStatusCode.BadRequest;
}
string userId = userVerification.Id;
TokensRequest request = new TokensRequest();
request.UserId = userId;
request.Token = Guid.NewGuid();
request.TokenTypeId = 2;
ItemResponse<int> tokenAddResponse = new ItemResponse<int>();
tokenAddResponse.Item = TokensService.Insert(request, userId);
if (tokenAddResponse.Item <= 0)
{
response = new ErrorResponse("A new token was not inserted.");
code = HttpStatusCode.BadRequest;
}
Guid uniqueId = request.Token;
EmailRequest emailRequest = new EmailRequest();
emailRequest.Email = model.Email;
emailRequest.Subject = "Confirm Email";
bool emailSent = MailService.ConfirmationEmail(emailRequest, uniqueId);
if (!emailSent)
{
response = new ErrorResponse("The confirmation email failed to send.");
code = HttpStatusCode.BadRequest;
}
return Request.CreateResponse(code, response);
}
public HttpResponseMessage forgotPassword(VerifyEmailRequest model)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
SuccessResponse response = new SuccessResponse();
ApplicationUser userVerification = _userService.GetUser(model.Email);
if (userVerification == null)
{
ErrorResponse er = new ErrorResponse("Cannot find a user with that email.");
return Request.CreateResponse(HttpStatusCode.BadRequest, er);
}
string userId = userVerification.Id;
TokensRequest request = new TokensRequest();
request.UserId = userId;
request.Token = Guid.NewGuid();
request.TokenTypeId = 1;
ItemResponse<int> tokenAddResponse = new ItemResponse<int>();
tokenAddResponse.Item = TokensService.Insert(request, userId);
if (tokenAddResponse.Item <= 0)
{
ErrorResponse er = new ErrorResponse("A new token was not inserted.");
return Request.CreateResponse(HttpStatusCode.BadRequest, er);
}
Guid uniqueId = request.Token;
EmailRequest emailRequest = new EmailRequest();
emailRequest.Email = model.Email;
emailRequest.Subject = "Password Reset";
bool emailSent = MailService.resetPasswordEmail(emailRequest, uniqueId);
if (!emailSent)
{
return Request.CreateResponse(HttpStatusCode.BadRequest, "The reset password email failed to send.");
}
return Request.CreateResponse(response);
}
