Exemplo n.º 1
0
        public async Task <string> ForgotPassword(string email)
        {
            var user = await userManager.FindByEmailAsync(email);

            if (user == null)
            {
                return("user not found");
            }

            var html = await File.ReadAllTextAsync("../Disco.BLL/EmailTemplates/ConfirmationEmail/index.html");

            var passwordToken = await userManager.GeneratePasswordResetTokenAsync(user);

            string url = $"disco://disco.app/token/{passwordToken}";
            EmailConfirmationModel model = new EmailConfirmationModel();

            model.MessageHeader  = "Email confirmation";
            model.MessageBody    = html.Replace("[token]", passwordToken).Replace("[email]", user.Email);
            model.ToEmail        = email;
            model.IsHtmlTemplate = true;

            await emailService.EmailConfirmation(model);

            return(passwordToken);
        }
Exemplo n.º 2
0
        public async Task <IActionResult> ConfirmEmail([FromBody] EmailConfirmationModel emailConfirmationModel)
        {
            emailConfirmationModel.Token = emailConfirmationModel.Token.Replace(" ", "+");
            var model = await _accountService.ConfirmEmailAsync(emailConfirmationModel);

            return(Ok(model));
        }
Exemplo n.º 3
0
        public async Task <BaseModel> ConfirmEmailAsync(EmailConfirmationModel model)
        {
            var emailConfirmationModel = new EmailConfirmationModel();

            var user = await _userRepository.FindByEmailAsync(model.Email);

            if (user == null)
            {
                emailConfirmationModel.Errors.Add(Constants.Errors.UsersNotExistError);
                return(emailConfirmationModel);
            }

            var result = await _userRepository.ConfirmEmailAsync(model.Email, model.Token);

            if (!result)
            {
                emailConfirmationModel.Errors.Add(Constants.Errors.EmailConfirmationError);
            }

            result = await _userRepository.UnlockAsync(user.Email);

            if (!result)
            {
                emailConfirmationModel.Errors.Add(Constants.Errors.UserLockError);
                return(emailConfirmationModel);
            }

            return(emailConfirmationModel);
        }
Exemplo n.º 4
0
 public MvcMailMessage ConfirmationTokenMessage(EmailConfirmationModel model)
 {
     ViewData.Model = model;
     return(Populate(x =>
     {
         x.Subject = "Activate your account " + model.SiteName;
         x.ViewName = "ConfirmAccount";
         x.To.Add(model.ToEmail);
     }));
 }
Exemplo n.º 5
0
        public async Task <bool> ConfirmEmail(EmailConfirmationModel model)
        {
            var user = await _userManager.FindByEmailAsync(model.Email);

            var decodedBytes = Convert.FromBase64String(model.Token);
            var token        = Encoding.Unicode.GetString(decodedBytes);
            var result       = await _userManager.ConfirmEmailAsync(user, token);

            return(result.Succeeded);
        }
Exemplo n.º 6
0
        public async Task <IActionResult> ConfirmEmail(EmailConfirmationModel model)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    throw new InvalidOperationException("Input Parameters Not In Correct Format");
                }

                var email = await EmailConfirmationService.ConfirmEmail(model.UserId, model.Token);

                string redirectUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}/EmailConfirmationSuccessful";
                EmailConfirmationResponse emailConfirmationResponse = new EmailConfirmationResponse
                {
                    Email = email,
                    ConfirmationStatus = EmailConfirmation.CONFIRMED
                };

                return(Ok(emailConfirmationResponse, "Email Confirmed Successfully", ResponseStatus.OK));
            }
            catch (InvalidOperationException ex)
            {
                EmailConfirmationResponse emailConfirmationResponse = new EmailConfirmationResponse
                {
                    ConfirmationStatus = EmailConfirmation.UNCONFIRMED
                };

                var user = await UserManager.FindByIdAsync(model.UserId);

                if (user != null)
                {
                    emailConfirmationResponse.Email = user.Email;
                }

                return(BadRequest(emailConfirmationResponse, ex.Message, ResponseStatus.APP_ERROR));
            }
            catch (Exception ex)
            {
                EmailConfirmationResponse emailConfirmationResponse = new EmailConfirmationResponse
                {
                    ConfirmationStatus = EmailConfirmation.UNCONFIRMED
                };

                var user = await UserManager.FindByIdAsync(model.UserId);

                if (user != null)
                {
                    emailConfirmationResponse.Email = user.Email;
                }



                return(BadRequest(emailConfirmationResponse, "Oops Something Went Wrong", ResponseStatus.FATAL_ERROR));
            }
        }
Exemplo n.º 7
0
        public Task SendEmailConfirmationAsync(EmailConfirmationModel emailConfirmationModel)
        {
            var sendEmailModel = new SendEmailModel
            {
                Email   = emailConfirmationModel.Email,
                Subject = "Confirm your email",
                Message = $"Please confirm your account by clicking this link: <a href='{HtmlEncoder.Default.Encode(emailConfirmationModel.Link)}'>link</a>"
            };

            return(SendEmailAsync(sendEmailModel));
        }
Exemplo n.º 8
0
        public async Task <IActionResult> ForgotPassword([FromBody] EmailConfirmationModel user)
        {
            var resetPasswordModel = await _accountService.ResetPasswordAsync(user.Email);

            string subject = Constants.EmailHeaders.ResetingPasswordConfirmation;
            string body    = $"New password: {resetPasswordModel.Password}. You can change it in account settings";

            await _emailHelper.SendAsync(resetPasswordModel.Email, subject, body);

            return(Ok(resetPasswordModel));
        }
Exemplo n.º 9
0
        public async Task <string> ConfirmEmailAsync(EmailConfirmationModel emailConfirmationModel)
        {
            var user = await _userManager.FindByEmailAsync(emailConfirmationModel.Email);

            if (user is null)
            {
                throw new Exception(Constants.Error.EMAILCONFIRMATION_USER_NOT_FOUND);
            }

            var result = await _userManager.ConfirmEmailAsync(user, emailConfirmationModel.Code);

            if (!result.Succeeded)
            {
                throw new Exception(Constants.Error.EMAILCONFIRMATION_EMAIL_DID_NOT_CONFIRMED);
            }

            return("email confirmed");
        }
Exemplo n.º 10
0
        public ActionResult SendAccountConfirmationEmail(string username, string token)
        {
            Account account = AccountRepos.Get(username);
            EmailConfirmationModel model = new EmailConfirmationModel()
            {
                SiteName          = siteName,
                SiteUrl           = siteUrl,
                UserName          = account.UserName,
                FirstName         = account.FirstName,
                ToEmail           = account.Email,
                ConfirmationToken = token,
                ConfirmationUrl   = siteUrl + "/Account/ConfirmAccount?u=" + account.UserName + @"&t" + token
            };

            UserMailer mailer = new UserMailer();

            mailer.ConfirmationTokenMessage(model).Send();
            return(RedirectToAction("RegistrationSuccess", "Account"));
        }
Exemplo n.º 11
0
        public async Task <EmailConfirmationModel> SignUpAsync(SignUpModel signUpModel)
        {
            var resultModel = new EmailConfirmationModel();

            var user = await _userRepository.FindByEmailAsync(signUpModel.Email);

            if (user != null)
            {
                resultModel.Errors.Add(Constants.Errors.EmailExistsError);
                return(resultModel);
            }


            var result = await _userRepository.CreateAsync(signUpModel.MapToEntity(), signUpModel.Password);

            if (!result)
            {
                resultModel.Errors.Add(Constants.Errors.CreateUserError);
                return(resultModel);
            }

            user = await _userRepository.FindByEmailAsync(signUpModel.Email);

            if (user == null)
            {
                resultModel.Errors.Add(Constants.Errors.CreateUserError);
                return(resultModel);
            }

            result = await _userRepository.AddToRoleAsync(user.Id, Enums.Role.RoleName.Client.ToString());

            if (!result)
            {
                resultModel.Errors.Add(Constants.Errors.CreateUserError);
                return(resultModel);
            }

            resultModel.Email = signUpModel.Email;
            resultModel.Token = await _userRepository.GenerateEmailConfirmationTokenAsync(user.Email);

            return(resultModel);
        }
Exemplo n.º 12
0
        public async Task <IActionResult> ConfirmEmail([FromBody] EmailConfirmationModel model)
        {
            if (model.UserId == null || model.Ctoken == null)
            {
                return(BadRequest());
            }
            var user = await _userManager.FindByIdAsync(model.UserId);

            model.Ctoken = HttpUtility.UrlDecode(model.Ctoken);
            var res = await _userManager.ConfirmEmailAsync(user, model.Ctoken);

            if (res.Succeeded)
            {
                return(Ok());
            }
            else
            {
                _logger.LogError("Invalid Email Content");
                return(Content("Invalid Email Content"));
            }
        }
Exemplo n.º 13
0
        public async Task EmailConfirmation(EmailConfirmationModel model)
        {
            using (var client = new SmtpClient())
            {
                MimeMessage message = new MimeMessage();
                message.From.Add(new MailboxAddress("Disco", emailOptions.Value.Mail));
                message.To.Add(new MailboxAddress(model.Name, model.ToEmail));
                message.Subject = model.MessageHeader;
                message.Body    = new TextPart(MimeKit.Text.TextFormat.Html)
                {
                    Text = model.MessageBody
                };

                client.Connect(emailOptions.Value.Host, emailOptions.Value.Port, true);
                client.AuthenticationMechanisms.Remove("XOAUTH2");
                client.Authenticate(emailOptions.Value.Name, emailOptions.Value.Password);

                var result = await client.SendAsync(message);

                logger.LogInformation(result);

                client.Disconnect(true);
            }
        }
Exemplo n.º 14
0
        public async Task <IActionResult> ConfirmEmail([FromQuery] EmailConfirmationModel emailConfirmationModel)
        {
            var result = await _accountService.ConfirmEmailAsync(emailConfirmationModel);

            return(Ok(result));
        }