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); }