public async Task SendVerifyEmailEmailAsync(string email, Guid userId, string token)
        {
            var message = CreateDefaultMessage("Verify Your Email", email);
            var model   = new VerifyEmailModel
            {
                Token       = WebUtility.UrlEncode(token),
                UserId      = userId,
                WebVaultUrl = _globalSettings.BaseServiceUri.VaultWithHash,
                SiteName    = _globalSettings.SiteName
            };

            await AddMessageContentAsync(message, "VerifyEmail", model);

            message.MetaData.Add("SendGridBypassListManagement", true);
            message.MetaData.Add("SendGridCategories", new List <string> {
                "VerifyEmail"
            });
            await _mailDeliveryService.SendEmailAsync(message);
        }
예제 #2
0
        public async Task <IHttpActionResult> VerifyEmail(VerifyEmailModel model)
        {
            if (model.UserId == null || model.Code == null)
            {
                return(ErrorApiResult(1, "Нет параметров"));
            }
            var            userId = long.Parse(model.UserId);
            IdentityResult result = await _userManager.ConfirmEmailAsync(userId, model.Code);

            if (result.Succeeded)
            {
                return(EmptyApiResult());
            }
            else
            {
                var errorsMessages = ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage));
                return(ErrorApiResult(1, errorsMessages));
            }
        }
예제 #3
0
        public async Task SendVerifyEmailEmailAsync(string email, Guid userId, string token)
        {
            var message = CreateDefaultMessage("Verify Your Email", email);
            var model   = new VerifyEmailModel
            {
                Token       = WebUtility.UrlEncode(token),
                UserId      = userId,
                WebVaultUrl = _globalSettings.BaseServiceUri.VaultWithHash,
                SiteName    = _globalSettings.SiteName
            };

            message.HtmlContent = await _engine.CompileRenderAsync("VerifyEmail", model);

            message.TextContent = await _engine.CompileRenderAsync("VerifyEmail.text", model);

            message.MetaData.Add("SendGridBypassListManagement", true);

            await _mailDeliveryService.SendEmailAsync(message);
        }
예제 #4
0
        public ActionResult VerifyEmail(string id, string token)
        {
            EmailVerifier userToken = _factory.CreateEmailVerifierDao().Get(id);

            try
            {
                if (userToken == null)
                {
                    return(View("~/Views/HttpErrors/404.cshtml"));
                }
                var verifyEmailModel = new VerifyEmailModel(userToken);
                return(View(verifyEmailModel.Verify(OrnamentContext.MemberShip.CurrentUser(), token, _factory)));
            }
            finally
            {
                if (userToken != null)
                {
                    _factory.CreateEmailVerifierDao().SaveOrUpdate(userToken);
                }
            }
        }
예제 #5
0
        public async Task <IActionResult> NeedVerification(VerifyEmailModel model)
        {
            if (ModelState.IsValid)
            {
                UserModel user = await _userManager.FindByEmailAsync(model.Email);

                if (user != null)
                {
                    if (Equals(user.EmailVerificationKey, model.VerificationKey))
                    {
                        user.EmailConfirmed = true;
                        await _userManager.UpdateAsync(user);

                        await _signInManager.SignOutAsync();

                        Microsoft.AspNetCore.Identity.SignInResult result =
                            await _signInManager.PasswordSignInAsync(user, model.Password, false, false);

                        if (result.Succeeded)
                        {
                            await _userManager.AddToRoleAsync(user, _configuration["DefaultRoleName"]);

                            return(RedirectToAction("Index", "Home"));
                        }
                    }
                    else
                    {
                        ModelState.AddModelError("", ApplicationResources.UserInterface.Common.VerificationKeyDoesNotMatch);
                    }
                }
                else
                {
                    ModelState.AddModelError("", ApplicationResources.UserInterface.Common.UserDoNotExist);
                }
            }
            return(View(model));
        }
예제 #6
0
        public async Task <string> VerifyEmail(string Token)
        {
            using var httpClient = new HttpClient();
            using var request    = new HttpRequestMessage(new HttpMethod("POST"), VerifyEmailRequestUri);
            VerifyEmailModel verifyEmailModel = new VerifyEmailModel()
            {
                IdToken = Token, RequestType = "VERIFY_EMAIL"
            };
            string s1 = JsonConvert.SerializeObject(verifyEmailModel);

            request.Content = new StringContent(s1);
            request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");

            var response = await httpClient.SendAsync(request);

            if (response.IsSuccessStatusCode)
            {
                return("OK");
            }
            else
            {
                return("Error");
            }
        }
예제 #7
0
        public string VerifyEmail([FromBody] VerifyEmailModel verifyEmailModel)
        {
            SignupDetails signupDetails = new SignupDetails();

            return(signupDetails.VerifyEmail(verifyEmailModel));
        }
 public bool VerifyEmail(VerifyEmailModel model)
 {
     model.Send(_factory);
     return(true);
 }
예제 #9
0
 public IActionResult VerifyEmail([FromBody] VerifyEmailModel model)
 {
     _userService.VerifyEmail(model.Token);
     return(Ok(new { message = "✓ Verification Success, You Can Now Login!" }));
 }
예제 #10
0
        private string generateEmailBody(string template, VerifyEmailModel model)
        {
            try
            {
                return Razor.Parse(template, model);
            }
            catch (Exception e)
            {

                logAccessor.CreateLog(DateTime.Now, this.GetType().ToString() + "." + System.Reflection.MethodBase.GetCurrentMethod().Name.ToString(), e.ToString());
                return e.Message;
            }
        }
예제 #11
0
        public bool SendVerificationMail(Guid guid, string name, string email)
        {
            try
            {
                string newString = HttpContext.Current.Request.Url.Authority.ToString();
                string guidstring = guid.ToString();

                VerifyEmailModel verifyEmailModel = new VerifyEmailModel()
                {
                    Name = name,
                    GuidString = guid.ToString(),
                    ClientUrl = "http://" + HttpContext.Current.Request.Url.Authority.ToString()
                };

                String messageBody = generateEmailBody(Manager.Properties.Resources.VerifyEmailTemplate.ToString(), verifyEmailModel);

                SendMessage("*****@*****.**", "Vestn", new String[1] { email }, null, null, "Verify Your Email to Create Your Vestn Account!", messageBody);

                return true;
            }
            catch (Exception ex)
            {
                logAccessor.CreateLog(DateTime.Now, this.GetType().ToString() + "." + System.Reflection.MethodBase.GetCurrentMethod().Name.ToString(), ex.ToString());

                return false;
            }
        }
예제 #12
0
        private void DoLogin(object parameter)
        {
            LoginModel loginModel;

            if (!IsFormValid(parameter, out loginModel))
            {
                return;
            }

            MainVm.LoggedIn = false;
            Loading         = true;
            ErrorMessage    = "";
            Task.Run(async() =>
            {
                try
                {
                    // Verify email first
                    if (ShowConfirmEmail)
                    {
                        var model = new VerifyEmailModel(Email, EmailToken);
                        await _userClient.VerifyEmail(model);
                    }
                    await _userClient.LoginAsync(loginModel.Email, loginModel.Password);

                    var details = await _userClient.GetCurrentUserDetails();
                    MainVm.Login(this, details);

                    ShowConfirmEmail = false;
                    Loading          = false;
                    Email            = "";
                }
                catch (IncorrectLoginException)
                {
                    Ui(() =>
                    {
                        ErrorMessage = "Invalid Username or Password";
                        Loading      = false;
                    });
                }
                catch (EmailVerificationNeededException)
                {
                    Ui(() =>
                    {
                        ShowConfirmEmail = true;
                        ErrorMessage     =
                            "This email is unconfirmed. Please enter the verification token sent to this email.";
                        Loading = false;
                    });
                }
                catch (UnauthorizedException)
                {
                    Ui(() =>
                    {
                        ErrorMessage = "Invalid Token";
                        Loading      = false;
                    });
                }
                catch (ApiException e)
                {
                    Ui(() =>
                    {
                        ErrorMessage = "An Unknown Error Occurred";
                        Loading      = false;
                    });
                }
            });
        }
 public VerifyEmailRequestModel(VerifyEmailModel model)
 {
     Email = model.Email;
     Code  = model.Token;
 }
예제 #14
0
        public async Task VerifyEmail(VerifyEmailModel verifyEmailModel)
        {
            var requestModel = new VerifyEmailRequestModel(verifyEmailModel);

            await PostAsync(Resources.VerifyEmailAction, requestModel);
        }
 public async Task <IdentityResult> VerifyEmail(VerifyEmailModel user)
 {
     return(await _userManager.ConfirmEmailAsync(user.UserId, user.Token));
 }