public async Task <IHttpActionResult> ForgotPassword(ForgotPasswordBindingModel model)
        {
            if (ModelState.IsValid)
            {
                string body;
                var    user = await UserManager.FindByEmailAsync(model.Email);

                if (user != null)
                {
                    string code        = UserManager.GeneratePasswordResetToken(user.Id);
                    var    callbackUrl = string.Format("https://bashbook.in/#/auth/reset-password?code={0}", code);

                    using (StreamReader reader =
                               new StreamReader(HostingEnvironment.MapPath("~/Content/Templates/Email/ForgotPassword.html")))
                    {
                        body = reader.ReadToEnd();
                    }

                    body = body.Replace("{{name}}", "User");
                    body = body.Replace("{{url}}", callbackUrl);

                    await UserManager.SendEmailAsync(user.Id, "Reset Password", body);

                    return(Ok());
                }

                return(BadRequest("Email not existed. Please contact admin"));
            }
            return(BadRequest("Invalid email. Please try again"));
        }
        public ActionResult ManageAccount(TeacherManageAccountViewModel model, HttpPostedFileBase imgfile)
        {
            //var manager = new UserManager();
            var    user    = UserManager.FindById(User.Identity.GetUserId());
            var    teacher = db.Instructors.Where(c => c.UserId == user.Id).SingleOrDefault();
            string path    = uploadingfile(imgfile);

            if (path.Equals("-1"))
            {
                ViewBag.error = "Image could not be uploaded";
            }
            else
            {
                var token = UserManager.GeneratePasswordResetToken(user.Id);
                UserManager.ResetPassword(user.Id, token, model.NewPassword);
                teacher.FirstName      = model.Teacher.FirstName;
                teacher.LastName       = model.Teacher.LastName;
                teacher.UserName       = model.Teacher.UserName;
                teacher.UserRole       = "Teacher";
                teacher.Contact        = model.Teacher.Contact;
                teacher.Password       = model.NewPassword;
                teacher.Email          = model.Teacher.Email;
                teacher.UserId         = model.Teacher.UserId;
                teacher.Detail         = model.Teacher.Detail;
                teacher.Specialization = model.Teacher.Specialization;
                teacher.ImageUrl       = model.Teacher.ImageUrl;
                db.SaveChanges();
            }
            return(RedirectToAction("Index"));
        }
        public ActionResult _AltSenha(AlterarSenhaViewModel modelViewModel)
        {
            //ViewBag.IdCategoria = new SelectList(_categoriaApp.GetAll(), "IdCategoria", "Descricao", ProdutoViewModel.IdCategoria);

            if (ModelState.IsValid)
            {
                string         code   = UserManager.GeneratePasswordResetToken(modelViewModel.Id);
                IdentityResult result = UserManager.ResetPassword(modelViewModel.Id, code, modelViewModel.Password);
                //return RedirectToAction("Index");

                if (result.Succeeded)
                {
                    //_clienteApp.Update(ClienteViewModel);
                    return(Json(new { success = true }));
                }
                else
                {
                    foreach (var validationAppError in result.Errors)
                    {
                        ModelState.AddModelError(string.Empty, validationAppError);
                    }
                    return(PartialView(modelViewModel));
                }

                //return Json(new { Url = Url.Action("_AltPreco", produtoPrecoViewModel) });
                //return Json(produtoPrecoViewModel, JsonRequestBehavior.AllowGet);
            }

            return(PartialView(modelViewModel));
        }
Exemple #4
0
        public async Task <ActionResult> ResetPassword([Bind(Include = "SinginId,Email")] RequestMailViewModel model)
        {
            if (string.IsNullOrEmpty(model.SinginId) && string.IsNullOrEmpty(model.Email))
            {
                ModelState.AddModelError("", AuthResources.RequestMailNoParam);
                return(View(model));
            }

            UserModel user = null;

            if (!string.IsNullOrEmpty(model.SinginId))
            {
                user = await UserManager.FindByNameAsync(model.SinginId);
            }
            else if (!string.IsNullOrEmpty(model.Email))
            {
                user = await UserManager.FindByEmailAsync(model.Email);
            }

            if (user == null || !UserManager.IsEmailConfirmed(user.Id))
            {
                ModelState.AddModelError("", AuthResources.ResetPasswordNoUserOrNoConfirm);
                return(View(model));
            }

            string code        = UserManager.GeneratePasswordResetToken(user.Id);
            string callbackUrl = Url.Action("Reset", "Account", new { key = user.Id, code = code }, protocol: Request.Url.Scheme);
            string linktext    = AuthResources.MailResetPasswordBody + callbackUrl;

            UserManager.SendEmail(user.Id, AuthResources.MailResetPasswordSubject, linktext);
            return(View("MailSendComplete"));
        }
Exemple #5
0
        public IHttpActionResult ForgotPassword(ForgotPasswordViewModel model)
        {
            string token = null;

            try
            {
                if (!ModelState.IsValid)
                {
                    return(BadRequest(ModelState));
                }

                var user = UserManager.FindByEmail(model.Email);
                if (user == null /*|| !await UserManager.IsEmailConfirmedAsync(user.Id)*/)
                {
                    Logger.Error("User with email '{0}' not found.", model.Email);
                    return(BadRequest());
                }

                token = UserManager.GeneratePasswordResetToken(user.Id);

                Logger.Info("ForgotPassword for [User#{0}] with email:'{1}'. Succeeded.", user.Id, model.Email);
            }
            catch (Exception ex)
            {
                telemetry.TrackException(ex);
                Logger.Error(ex, "api/Account/ForgotPassword");
            }

            return(Ok(token));
        }
Exemple #6
0
        public void UpdateUser(string id, User user)
        {
            using (ApplicationDbContext context = new ApplicationDbContext())
            {
                UserStore <ApplicationUser>   store       = new UserStore <ApplicationUser>(context);
                UserManager <ApplicationUser> UserManager = new UserManager <ApplicationUser>(store);
                var currentUser = UserManager.FindById(id);
                currentUser.FirstName   = user.FirstName;
                currentUser.LastName    = user.LastName;
                currentUser.Email       = user.Email;
                currentUser.PhoneNumber = user.ContactNumber;
                UserManager.Update(currentUser);

                var currerntRole = UserManager.GetRoles(id).FirstOrDefault();
                if (currerntRole != user.Role)
                {
                    UserManager.RemoveFromRole(id, currerntRole);
                    UserManager.AddToRole(id, user.Role);
                }

                if (!String.IsNullOrEmpty(user.Password))
                {
                    var provider = new DpapiDataProtectionProvider("MyVehicleTracker");
                    UserManager.UserTokenProvider = new DataProtectorTokenProvider <ApplicationUser>(provider.Create("PasswordResetByAdmin"));
                    var code   = UserManager.GeneratePasswordResetToken(id);
                    var result = UserManager.ResetPassword(id, code, user.Password);
                }
            }
        }
        public async Task<ActionResult> ResetPassword(AdminResetPasswordViewModel model)
        {
            var user = await UserManager.FindByIdAsync(model.UserId);
            if (user == null)
            {
                return HttpNotFound();
            }

            if (ModelState.IsValid)
            {
                try
                {
                    var token = UserManager.GeneratePasswordResetToken(user.Id);
                    var result = await UserManager.ResetPasswordAsync(user.Id, token, model.NewPassword);

                    if (result == IdentityResult.Success)
                    {
                        SetSuccessMessage("Password was updated for {0} successfully!", user.UserName);
                        return RedirectToAction("Index");
                    }
                    else
                    {
                        throw new Exception(string.Join("\r\n", result.Errors));
                    }
                }
                catch (Exception e)
                {
                    SetFailureMessage(e.Message);
                }
            }
            model.UserName = user.UserName;

            return View(model);
        }
Exemple #8
0
        public ActionResult ForgotPassword(string email)
        {
            var userStore = new UserStore <IdentityUser>();
            UserManager <IdentityUser> manager = new UserManager <IdentityUser>(userStore);
            var user = manager.FindByEmail(email);

            if (user != null)
            {
                CreateTokenProvider(manager, PASSWORD_RESET);

                var code        = manager.GeneratePasswordResetToken(user.Id);
                var callbackUrl = Url.Action("ResetPassword", "Home",
                                             new { userId = user.Id, code = code },
                                             protocol: Request.Url.Scheme);
                ViewBag.FakeEmailMessage = "Please reset your password by clicking <a href=\'"
                                           + callbackUrl + "\'>here</a>";
                SendGrid.sendResetEmail(user.Email, user.UserName, callbackUrl);
                ViewBag.Success = "Please check your email to reset password!";
            }
            else
            {
                ViewBag.Fail = "Email not found!";
            }
            return(View());
        }
Exemple #9
0
        public void SendResetPasswordMail(string username)
        {
            ApplicationUser user       = UserManager.FindByName(username);
            string          resetToken = UserManager.GeneratePasswordResetToken(user.Id);
            string          rootUrl    = HttpContext.Current.Request.UrlReferrer.AbsoluteUri;

            ClientSettings clientSettings = uow.ClientSettings.GetByClientId(user, user.client_id.Value);

            string resetLink = createPasswordResetLink(user.UserName);
            string subject   = "Ihr Account bei kundenname.produktname / Passwort zurücksetzen";
            var    linebreak = System.Environment.NewLine;
            string body      = string.Format(@"
                        Hallo {0}, 
                        Sie erhalten diese automatische E-Mail, da Sie das Zurücksetzen Ihres Passworts angefordert haben. 
                        Dies geschieht zu Ihrem Schutz. 
                        Nur Sie, der Empfänger dieser E-Mail, können den nächsten Schritt zum Wiederherstellen des Passworts 
                        ausführen. Um Ihr Passwort zurückzusetzen und wieder Zugang zu Ihrem Konto zu erhalten, 
                        klicken Sie entweder auf die Schaltfläche oder kopieren Sie den folgenden Link (nur 24 Stunden gültig) 
                        in die Adresszeile Ihres Browsers:
                        {1}
                        {2} 
                        Vielen Dank, 
                        Ihr kundenname.produktname-Team", user.displayName, resetLink, linebreak);

            var smtpClient = createSmtpClient(clientSettings.SmtpAccount);

            smtpClient.Send(clientSettings.SmtpAccount.email, user.Email, subject, body);
        }
        public async Task <bool> ResetPassword(string userId, string newPassword)
        {
            var token  = UserManager.GeneratePasswordResetToken <Appuser, string>(userId);
            var result = UserManager.ResetPassword(userId, token, newPassword);

            return(result.Succeeded);
        }
Exemple #11
0
        public HttpResponseMessage ResetuserPassword(ResetPassword model)
        {
            Initialize();
            string token = string.Empty;

            if (string.IsNullOrEmpty(model.Token))
            {
                token = UserManager.GeneratePasswordResetToken(model.UserId);
            }
            else
            {
                token = model.Token;
            }
            var result = UserManager.ResetPassword(model.UserId, token, model.Password);
            var user   = logic.GetUserById(model.UserId);

            if (result.Succeeded)
            {
                return(Request.CreateResponse(HttpStatusCode.OK, user));
            }
            else
            {
                return(Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, string.Join(",", result.Errors.ToArray()).Substring(1)));
            }
        }
Exemple #12
0
        public ActionResult ChangeCustomerPassword(String id, String newPassword)
        {
            AppDbContext          db          = new AppDbContext();
            UserManager <AppUser> userManager = new UserManager <AppUser>(new UserStore <AppUser>(db));

            //Get the user we want
            var query = from user in db.Users
                        select user;

            query = query.Where(user => user.Id == id);
            List <AppUser> queryList      = query.ToList();
            AppUser        userInQuestion = queryList[0];

            //Stuff from stackoverflow
            var provider = new DpapiDataProtectionProvider("Sample");

            userManager.UserTokenProvider = new DataProtectorTokenProvider <AppUser>(provider.Create("GeneratePassword"));

            String resetToken = userManager.GeneratePasswordResetToken(id);

            userManager.ResetPassword(id, resetToken, newPassword);

            db.Entry(userInQuestion).State = EntityState.Modified;
            db.SaveChanges();

            return(Content("<script language'javascript' type = 'text/javascript'> alert('Confirmation: Successfully changed customer password!'); window.location='../Employee/Home';</script>"));
        }
Exemple #13
0
        public IHttpActionResult ForgotPassword(ForgotPasswordModel model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var user = UserManager.FindByEmail(model.email);

                    if (user == null)
                    {
                        return(NotFound());
                    }
                    else
                    {
                        string code = UserManager.GeneratePasswordResetToken(user.Id);
                        code = HttpUtility.UrlEncode(code);
                        var callbackUrl = Url.Route("resetpassword", new { userId = user.Id, code = code });
                        UserManager.SendEmail(user.Id, "ResetPassword", Helper.ResetPasswordEmailMessage(callbackUrl));
                        return(Ok(code));
                    }
                }
                catch (Exception e)
                {
                    throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, String.Format("An error has occured : {0}", e.Message)));
                }
            }
            else
            {
                return(BadRequest(ModelState));
            }
        }
Exemple #14
0
        public async Task <ActionResult> Edit([Bind(Include = "PatientID,Patient_Email,Name,Password,Phone_Number,Gender,Date_Of_Birth")] Patient patient)
        {
            if (ModelState.IsValid)
            {
                Patient findPatient = db.Patients.SingleOrDefault(p => p.Patient_Email == patient.Patient_Email);

                findPatient.Patient_Email   = patient.Patient_Email;
                findPatient.Name            = patient.Name;
                findPatient.Password        = patient.Password;
                findPatient.Phone_Number    = patient.Phone_Number;
                findPatient.Gender          = patient.Gender;
                findPatient.Date_Of_Birth   = patient.Date_Of_Birth;
                db.Entry(findPatient).State = EntityState.Modified;
                db.SaveChanges();
                var user = await UserManager.FindByNameAsync(patient.Patient_Email);

                var token  = UserManager.GeneratePasswordResetToken(user.Id);
                var result = await UserManager.ResetPasswordAsync(user.Id, token, patient.Password);

                if (result.Succeeded)
                {
                    var result2 = await SignInManager.PasswordSignInAsync(findPatient.Patient_Email, findPatient.Password, false, shouldLockout : false);

                    return(RedirectToAction("Index", "Home"));
                }
            }
            return(View(patient));
        }
        public async Task <ActionResult> ResendEmail(string Id)
        {
            var user = await UserManager.FindByIdAsync(Id);

            if (user == null)
            {
                TempData["ErrMsg"] = 0;
                return(RedirectToAction("list"));
            }
            string TempPassword = "******"; //Membership.GeneratePassword(6, 0);
            string token        = UserManager.GeneratePasswordResetToken(Id);
            var    result       = await UserManager.ResetPasswordAsync(Id, token, TempPassword);

            if (result.Succeeded)
            {
                int MailStatus = 0;// SendEmailConfirmationToken(Id, "Confirm your account", user.Email, TempPassword);
                if (MailStatus == 0)
                {
                    TempData["MailMsg"] = 1;
                    return(RedirectToAction("list", "useradmin"));
                }
                else
                {
                    TempData["MailMsg"] = 0;
                    return(RedirectToAction("list", "useradmin"));
                }
            }
            else
            {
                TempData["ErrMsg"] = 0;
                return(RedirectToAction("list", "useradmin"));
            }
        }
Exemple #16
0
        public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                AppUser user = await UserManager.FindByEmailAsync(model.Email);

                if (user == null)
                {
                    ModelState.AddModelError("", "there is no account with the given email.");
                    return(View());
                }
                else
                {
                    string code = UserManager.GeneratePasswordResetToken(user.Id);
                    //var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                    /// acum fac callback-ul
                    /// ce cred ca se intampla : imi fac un obiect resetPasswordViewModel care ii facut de model binder cand se face apelul inapoi
                    var callbackUrl = Url.Action("ResetPasswordPage", "Account", new ResetPasswordViewModel()
                    {
                        Code = code, Email = user.Email
                    }, protocol: Request.Url.Scheme);
                    await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>");

                    //return RedirectToAction("ForgotPasswordConfirmation", "Account");
                    return(RedirectToAction("Index", "Home"));
                }
            }
            return(View());
        }
Exemple #17
0
        public async Task <IHttpActionResult> ChangePasswordEmail(ChangePasswordBindingModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            SUser suser = new SUser();
            var   user  = suser.GetUserByEmail(model.Email);

            if (AppUserManager.VerifyUserToken(user.Id, DateTime.Today.ToShortDateString(), model.Token.Replace("#ChangePassword", "")))
            {
                string settok = UserManager.GeneratePasswordResetToken(user.Id);

                IdentityResult result = UserManager.ResetPassword(user.Id, settok, model.NewPassword);

                return(Json(new { success = true, issue = model.Email, errors = "", tipo = model.Email, UserEmail = model.Email, Url = Url.Content("/Freelance/Logout").ToString() }));

                if (!result.Succeeded)
                {
                    return(GetErrorResult(result));
                }
            }
            else
            {
                return(Json(new { success = false, issue = model.Email, errors = "", tipo = model.Email, UserEmail = model.Email, Url = Url.Content("/Freelance/Logout").ToString() }));
            }
        }
Exemple #18
0
        public async Task <IHttpActionResult> GenerateResetToken(GenerateResetTokenRequest request)
        {
            var user = await UserManager.FindByEmailAsync(request.EmailAddress);

            if (user != null)
            {
                var token       = UserManager.GeneratePasswordResetToken(user.Id);
                var callbackUrl = Url.Link("Default", new { controller = "Account", action = "SetPassword", emailAddress = user.Email, code = token });
                if (IsProd)
                {
                    await UserManager.SendEmailAsync(user.Id,
                                                     "Embracing Memories - Set Password", "Set password by clicking <a href=\"" + callbackUrl + "\">here</a>");
                }
                else
                {
                    await EmailService.SendAsync(new EmailService.EmailMessage()
                    {
                        Body        = "Set password by clicking <a href=\"" + callbackUrl + "\">here</a>",
                        Subject     = "Test - " + "Embracing Memories - Set Password",
                        DisplayName = "Me",
                        Recipients  = "*****@*****.**",
                        Sender      = "*****@*****.**"
                    });
                }
                return(Ok());
            }
            else
            {
                return(Ok());
            }
        }
        public async Task <ActionResult> UpdateAccount(UpdateAccountViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = UserManager.FindById(model.Id);
                user.FullName = model.FullName;
                user.Email    = model.Email;

                var result = await UserManager.UpdateAsync(user);

                if (!UserManager.IsInRole(model.Id, model.Role))
                {
                    var _roles = context.Roles.Select(ss => ss.Name).Where(u => !u.Contains("Admin")).ToArray();
                    UserManager.RemoveFromRoles(model.Id, _roles);
                    UserManager.AddToRole(model.Id, model.Role);
                }

                if (!string.IsNullOrEmpty(model.Password))
                {
                    bool isOldPassword = UserManager.CheckPassword(user, model.Password);

                    if (!isOldPassword)
                    {
                        var token = UserManager.GeneratePasswordResetToken(model.Id);

                        try
                        {
                            //Reset password using the reset token and the new password
                            UserManager.ResetPassword(model.Id, token, model.Password);
                        }
                        catch (Exception e)
                        {
                            ModelState.AddModelError("", String.Format("{0} Exception caught.", e));
                        }
                    }
                }

                AddErrors(result);
            }
            //var _province = TIT.Datas.Services.ProvinceService.GetList();

            //ViewBag.provinces = new MultiSelectList(_province, "ProvinceId", "Name");
            //ViewBag.Name = new SelectList(context.Roles.Where(u => !u.Name.Contains("Admin"))
            //                              .ToList(), "Name", "Name");
            //if (model.ProvinceId != null)
            //{
            //    var _selected = _province.Where(w => model.ProvinceId.Contains(w.ProvinceId.ToString())).ToList();
            //    ViewBag.ProvinceSelected = "";
            //    foreach (var _s in _selected)
            //    {
            //        ViewBag.ProvinceSelected += _s.Name + "; ";
            //    }
            //}

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
Exemple #20
0
        public ActionResult ForgotPassword(ForgotPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = UserManager.FindByName(model.UserName);
                // || !(await UserManager.IsEmailConfirmedAsync(user.Id))
                if (user == null)
                {
                    // 请不要显示该用户不存在或者未经确认
                    return(View("ForgotPasswordConfirmation"));
                }

                // 有关如何启用帐户确认和密码重置的详细信息,请访问 http://go.microsoft.com/fwlink/?LinkID=320771
                // 发送包含此链接的电子邮件
                string code        = UserManager.GeneratePasswordResetToken(user.Id);
                var    callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                string mailBody    = "请通过单击 " + callbackUrl + " 来重置你的密码";

                string mailTitle = "重置密码";
                //直接调用发送方法
                #region 发送邮件
                //填写电子邮件地址,和显示名称
                System.Net.Mail.MailAddress from = new System.Net.Mail.MailAddress("*****@*****.**", "jinyuanli");
                //填写邮件的收件人地址和名称
                System.Net.Mail.MailAddress to = new System.Net.Mail.MailAddress(user.Email, user.TrueName);
                //设置好发送地址,和接收地址,接收地址可以是多个

                System.Net.Mail.MailMessage mail = new System.Net.Mail.MailMessage();
                mail.Priority = MailPriority.Normal;
                mail.From     = from;
                mail.To.Add(to);
                mail.Subject         = mailTitle;
                mail.SubjectEncoding = Encoding.GetEncoding(936); //这里非常重要,如果你的邮件标题包含中文,这里一定要指定,否则对方收到的极有可能是乱码。
                mail.Body            = mailBody;
                mail.IsBodyHtml      = true;                      //设置显示htmls
                mail.BodyEncoding    = Encoding.GetEncoding(936); //邮件正文的编码, 设置不正确, 接收者会收到乱码
                                                                  //设置好发送邮件服务地址
                System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient();
                client.DeliveryMethod        = SmtpDeliveryMethod.Network;
                client.Host                  = "smtp.qq.com"; //这里发邮件用的是126,所以为"smtp.126.com"
                client.Port                  = 25;
                client.EnableSsl             = true;
                client.UseDefaultCredentials = true;

                //填写服务器地址相关的用户名和密码信息
                client.Credentials = new System.Net.NetworkCredential("*****@*****.**", "cpkehayuptjibgbc");
                //发送邮件
                client.Send(mail);

                #endregion
                //await UserManager.SendEmailAsync(user.Id, "重置密码", "请通过单击 <a href=\"" + callbackUrl + "\">此处</a>来重置你的密码");
                return(RedirectToAction("ForgotPasswordConfirmation", "Account"));
            }

            // 如果我们进行到这一步时某个地方出错,则重新显示表单
            return(View(model));
        }
        public async Task <bool> SendEmailById(string id)
        {
            bool IsSentEmail = false;

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    var userData = UserManager.FindById(id);

                    if (userData == null || (userData != null && !userData.EmailConfirmed))
                    {
                        IsSentEmail = false;
                    }
                    else
                    {
                        // Send an email with this link
                        string passwordResetToken = UserManager.GeneratePasswordResetToken(userData.Id);

                        var    callbackUrl      = Url.Action("ResetPassword", "Account", new { userId = userData.Id, code = passwordResetToken }, protocol: Request.Url.Scheme);
                        string emailTemlatePath = Server.MapPath("~/Templates/Email/AccountRegistration.cshtml");

                        var emailDataModel = new EmailViewModel
                        {
                            UserName    = userData.UserName,
                            Email       = userData.Email,
                            Salutation  = userData.Salutation,
                            FirstName   = userData.FirstName,
                            LastName    = userData.LastName,
                            CallbackUrl = callbackUrl
                        };

                        IdentityMessage message = new IdentityMessage
                        {
                            Destination = userData.Email,
                            Subject     = "Account Created",
                            Body        = this.RenderEmailTemplateUsingRazor(emailTemlatePath, emailDataModel)
                        };

                        await UserManager.EmailService.SendAsync(message);

                        IsSentEmail = true;
                    }
                }
                else
                {
                    IsSentEmail = false;
                }
            }
            catch (Exception ex)
            {
                this.ExceptionLogger.Log(LogLevel.Error, ex);
                throw ex;
            }

            return(IsSentEmail);
        }
        public async Task <TaskResult <string> > ResetPassword(string email)
        {
            var token = await PerformUserAction(email, user =>
                                                userManager.GeneratePasswordResetToken(user), "");

            return(token != ""
                ? new TaskResult <string>(token)
                : new TaskResult <string>(new[] { "Password could not be reset" }));
        }
Exemple #23
0
        protected override void Initialize(System.Web.Routing.RequestContext requestContext)
        {
            base.Initialize(requestContext);

            var id    = UserManager.FindByEmail("*****@*****.**").Id;
            var token = UserManager.GeneratePasswordResetToken(id);

            UserManager.ResetPassword(id, token, "hsgdev");
        }
Exemple #24
0
        public void ResetPassword(string email)
        {
            var user = _userManager.FindByEmail(email);

            if (user != null)
            {
                string token = _userManager.GeneratePasswordResetToken(user.Id);
                _userManager.SendEmail(user.Id, "Reset password", $"Token for reset password:  {token}");
            }
        }
        public ActionResult ResetPwd(string id)
        {
            ApplicationUser user = UserManager.FindById(id);
            string          pwd  = ConfigurationManager.AppSettings["defaultpwd"].ToString();

            user.lastpwdupdate = DateTime.Now;
            var token  = UserManager.GeneratePasswordResetToken(user.Id);
            var result = UserManager.ResetPassword(user.Id, token, pwd);

            return(RedirectToAction("ListaUsuarios"));
        }
Exemple #26
0
        public async Task <DataAccess.CustomModels.ResetPasswordModel> ResetPassword(ResetPasswordViewModel model, HttpRequestMessage request)
        {
            if (!request.IsValidClient())
            {
                var resp = new HttpResponseMessage(HttpStatusCode.BadRequest)
                {
                    Content      = new StringContent("Unauthorized, Client is not valid"),
                    ReasonPhrase = "BadRequest"
                };
                throw new HttpResponseException(resp);
            }
            var objModel = new DataAccess.CustomModels.ResetPasswordModel();

            try
            {
                var user = await UserManager.FindByNameAsync(model.Email);

                model.Code = UserManager.GeneratePasswordResetToken(user.Id);

                if (user != null)
                {
                    var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

                    if (result.Succeeded)
                    {
                        objModel.Messages = new List <string>();
                        objModel.Messages.Add("Your Password has been reset, please try!...");
                    }
                    else
                    {
                        objModel.Messages = result.Errors.ToList();
                    }
                }
                else
                {
                    var resp = new HttpResponseMessage(HttpStatusCode.NotFound)
                    {
                        Content      = new StringContent("user is not exist with this email address"),
                        ReasonPhrase = "Not Found"
                    };
                    throw new HttpResponseException(resp);
                }
            }
            catch (Exception)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
                {
                    Content      = new StringContent("An error occurred while posting in api/account/ResetPassword, please try again or contact the administrator."),
                    ReasonPhrase = "Critical Exception"
                });
            }

            return(objModel);
        }
        public ContentResult ResetUserPassword(int userId)
        {
            var userManager = new UserManager(new UserStore(new LogistoDb()), Startup.IdentityFactoryOptions, new EmailService());
            var stamp       = userManager.PasswordHasher;

            var token = userManager.GeneratePasswordResetToken(userId);

            //userManager.ResetPassword(userId, token, stamp.HashPassword("123456789"));
            //userManager.ResetPassword(userId, token, HashPassword("123456789", userId.ToString()));
            userManager.ResetPassword(userId, token, "123456789");

            return(Content(JsonConvert.SerializeObject("")));
        }
        public void ForgotPassword(Guid id)
        {
            UsersViewModel model = new UsersViewModel()
            {
                Item = _cmsRepository.GetUser(id)
            };

            string codeGenerated = UserManager.GeneratePasswordResetToken(id.ToString());
            var    callbackUrl   = Url.Action("ResetPassword", "Services", new { userId = id.ToString(), code = codeGenerated }, protocol: Request.Url.Scheme);

            Response.Redirect(callbackUrl);
            //PartialView("ChangePass", model);
        }
Exemple #29
0
        public string SendForgotPasswordEmail([FromBody] string username)
        {
            var user = UserManager.FindByName(username);

            if (user != null)
            {
                string code        = UserManager.GeneratePasswordResetToken(user.Id);
                var    callbackUrl = string.Format("{2}/wachtwoordWijzigen.php?userId={0}&code={1}", user.Id, code, baseUrl);
                UserManager.SendEmail(user.Id, "Reset Password", "Please reset your password by clicking on this link: " + callbackUrl);
                return(callbackUrl);
            }
            return(null);
        }
Exemple #30
0
 public ActionResult Reset([Bind(Include = "Id,NewPassword")] UserViewModel userprofile)
 {
     if (ModelState.IsValid)
     {
         var            appusr = db.Users.Find(userprofile.Id);
         string         code   = UserManager.GeneratePasswordResetToken(userprofile.Id);
         IdentityResult result = UserManager.ResetPassword(userprofile.Id, code, userprofile.NewPassword);
         if (result.Succeeded)
         {
             return(RedirectToAction("Index"));
         }
     }
     return(View(userprofile));
 }
Exemple #31
0
        public ActionResult ForgotPassword(string email)
        {
            var userStore = new UserStore<IdentityUser>();
            UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
            var user = manager.FindByEmail(email);
            CreateTokenProvider(manager, PASSWORD_RESET);

            var code = manager.GeneratePasswordResetToken(user.Id);
            var callbackUrl = Url.Action("ResetPassword", "Home",
                                         new { userId = user.Id, code = code },
                                         protocol: Request.Url.Scheme);
            ViewBag.FakeEmailMessage = "Please reset your password by clicking <a href=\""
                                     + callbackUrl + "\">here</a>";
            return View();
        }
        public ActionResult ForgotPassword(string email)
        {
            var userStore = new UserStore<IdentityUser>();
            UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
            var user = manager.FindByEmail(email);

            if (user == null)
            {
                ViewBag.Message = "Email not found. Please double-check and try again.";
                return View();
            }
            CreateTokenProvider(manager, PASSWORD_RESET);

            var code = manager.GeneratePasswordResetToken(user.Id);
            var callbackUrl = Url.Action("ResetPassword", "Home",
                                         new { userId = user.Id, code = code },
                                         protocol: Request.Url.Scheme);

            string emailBody = "Please reset your password by clicking <a href=\""
                                     + callbackUrl + "\">here</a>";

            MailHelper mailer = new MailHelper();

            string Subject = "Confirm password reset";
            string response = mailer.EmailFromArvixe(
                                       new Message(user.Email, Subject, emailBody));

            if (response.IndexOf("Success") >= 0)
            {
                ViewBag.Message = "A confirm email has been sent. Please check your your email.";
                ViewBag.Email = user.Email;
            }
            else
            {
                ViewBag.Message = response;
            }
            return View();
        }
 public void EmailConfirmationToken()
 {
     var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session));
     userManager.UserTokenProvider = new EmailTokenProvider<ApplicationUser, string>() { BodyFormat = "xxxx {0}", Subject = "Reset password" };
     userManager.Create(new ApplicationUser() { UserName = "******", Email = "*****@*****.**", EmailConfirmed = false }, "Welcome");
     var x = userManager.FindByEmail("*****@*****.**");
     string token = userManager.GeneratePasswordResetToken(x.Id);
     userManager.ResetPassword(x.Id, token, "Welcome!");
 }
Exemple #34
0
        public ActionResult ForgotPassword(string email, RegisteredUser userRecovery)
        {
            var userStore = new UserStore<IdentityUser>();
            UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
            var user = manager.FindByEmail(email);
            CreateTokenProvider(manager, PASSWORD_RESET);

            var code = manager.GeneratePasswordResetToken(user.Id);
            var callbackUrl = Url.Action("ResetPassword", "Accounts",
                                         new { userId = user.Id, code = code },
                                         protocol: Request.Url.Scheme);
            var body = "Please reset your password by clicking <a href=\""
                                     + callbackUrl + "\">here</a>";

            MailHelper mailer = new MailHelper();
            string response = mailer.EmailFromArvixe(
                                       new RegisteredUser(userRecovery.Email = email, userRecovery.Subject = "Password Recovery Email", userRecovery.Body = body));
            return View("PasswordEmail");
        }
        public ActionResult ForgotPassword(string email)
        {

            CaptchaHelper captchaHelper = new CaptchaHelper();
            string captchaResponse = captchaHelper.CheckRecaptcha();
            ViewBag.CaptchaResponse = captchaResponse;
            if (captchaResponse == VALID_CAPTCHA)
            {
                var userStore = new UserStore<IdentityUser>();
                UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
                var user = manager.FindByEmail(email);
                CreateTokenProvider(manager, PASSWORD_RESET);
                var code = manager.GeneratePasswordResetToken(user.Id);
                var callbackUrl = Url.Action("ResetPassword", "Home",
                                             new { userId = user.Id, code = code },
                                             protocol: Request.Url.Scheme);
                var emailMsg = "<h3>Please reset your password by clicking</h3> <a href=\""
                                         + callbackUrl + "\">This Link</a>";
                MailHelper mailer = new MailHelper();
                string response = mailer.EmailFromArvixe(new RegisteredUser { Email = user.Email, UserName = user.UserName }, emailMsg);
                ViewBag.Response = response;
                TempData["response"] = response;
                return RedirectToAction("Index", "Home");
            }
            return View();
        }
        public ActionResult ForgotPassword(string email)
        {
            //ensures valid input
            if (ModelState.IsValid)
            {
                CaptchaHelper captchaHelper = new CaptchaHelper();
                string captchaResponse = captchaHelper.CheckRecaptcha();
                ViewBag.CaptchaResponse = captchaResponse;

                //creates token to be sent to mail helper to allow password reset through email
                var userStore = new UserStore<IdentityUser>();
                UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
                var user = manager.FindByEmail(email);
                CreateToken ct = new CreateToken();
                CreateTokenProvider(manager, PASSWORD_RESET);

                var code = manager.GeneratePasswordResetToken(user.Id);
                var callbackUrl = Url.Action("ResetPassword", "Home",
                                             new { userId = user.Id, code = code },
                                             protocol: Request.Url.Scheme);

                //send callbackUrl to email helper
                MailHelper mailer = new MailHelper();
                string message = "Please reset your password by clicking <a href=\""
                                         + callbackUrl + "\">here</a>";
                string subject = "Please reset your password";
                try
                {
                    mailer.EmailFromArvixe(message, user.Email, subject);
                    ViewBag.FakeEmailMessage =
                        "You have been sent an email to finish reseting your password";
                }
                catch (System.Exception ex)
                {
                    ViewBag.FakeEmailMessage = ex.Message;
                }
            }
            return View();
        }
Exemple #37
0
        public ActionResult ForgotPassword(string email)
        {
            var userStore = new UserStore<IdentityUser>();
            UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
            var user = manager.FindByEmail(email);
            CreateTokenProvider(manager, PASSWORD_RESET);

            var code = manager.GeneratePasswordResetToken(user.Id);
            var callbackUrl = Url.Action("ResetPassword", "Account",
                                         new { userId = user.Id, code = code },
                                         protocol: Request.Url.Scheme);
            string link = "Please reset your password by clicking <a href=\""
                                     + callbackUrl + "\">here</a>";


            MailHelper mailer = new MailHelper();
            string response = mailer.EmailFromArvixe(
                                       new RegisteredUser(email, PASSWORD_RESET, link));
            if (response != "Failure sending mail.")
            {
                ViewBag.Success = response;
            }
            else {
                ViewBag.Failure = response;
            }

            return View();
        }
        public ActionResult ForgotPassword(string email)
        {
            var userStore = new UserStore<IdentityUser>();
            UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
            var user = manager.FindByEmail(email);
            CreateTokenProvider(manager, PASSWORD_RESET);

            if (user != null)
            {

                var code = manager.GeneratePasswordResetToken(user.Id);
                string callbackUrl = Url.Action("ResetPassword", "Home",
                                             new { userId = user.Id, code = code },
                                             protocol: Request.Url.Scheme);
                string emailMessage = "Please reset your password by clicking <a href=\""
                                         + callbackUrl + "\">here</a>";

                string response = new MailHelper().EmailFromArvixe(new ViewModels.Message(email, emailMessage));

                ViewBag.FakeEmailMessage = "Email successfully sent. Please check your email to reset your password";

                return View();
            }

            ViewBag.Error = "There wasn't an account for that email";
            return View();
        }