public ActionResult EditStaffAccount(AdminChangePassViewModel model)
        {
            var staff = _context.Users
                        .OfType <Staff>()
                        .SingleOrDefault(t => t.Id == model.Id);

            if (_context.Users
                .OfType <Staff>()
                .ToList()
                .Any(t => t.Email == model.Email))
            {
                ModelState.AddModelError("Email", "This email has registered before");
            }

            staff.Email = model.Email;
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            if (staff.PasswordHash != null)
            {
                _userManager.RemovePassword(staff.Id);
            }
            _userManager.AddPassword(staff.Id, model.Password);
            _context.SaveChanges();

            return(RedirectToAction("StaffAccountView", "Admin"));
        }
        public ActionResult ChangePassword(ProfileSettingsViewModel model)
        {
            var db   = new ApplicationDbContext();
            var user = db.Users.FirstOrDefault(c => c.UserName == model.UserName);

            HTMLHelper.BindModel(user);
            try
            {
                db.SaveChanges();
                var password = model.Password;
                if (password.IsNotNullOrEmpty())
                {
                    UserManager.RemovePassword(user.Id);
                    UserManager.AddPassword(user.Id, password);
                    SetSuccessMessage("New password has been saved!");
                }
                else
                {
                    SetSuccessMessage();
                }
            }
            catch (Exception e)
            {
                logger.Debug("Change password Failed!", e);
                SetErrorMessage();
            }

            return(View("Overall"));
        }
Exemple #3
0
        public JsonResult RegisterInfoResetPassword(string UserId)
        {
            try
            {
                var    entity       = aspNetUserService.GetByUserId(Convert.ToInt32(UserId));
                string EmployeeName = string.Empty;
                EmployeeName = officeExecutiveService.GetByEmail(entity.UserName).ExecutiveName;

                Random rnd        = new Random();
                int    myRandomNo = rnd.Next(10000000, 99999999);
                //var myRandomNo = "12345678";

                userManager.RemovePassword(entity.Id);
                userManager.AddPassword(entity.Id, myRandomNo.ToString());

                sPService.GetDataBySqlCommand("UPDATE AspNetUsers SET Hashing='" + myRandomNo.ToString() + "' WHERE UserId=" + UserId);

                ReportHelper.SendEmail(entity.UserName, "Password Reset Confirmation", PopulateBody(EmployeeName, myRandomNo.ToString()));

                return(Json(new { Result = "Ok", Message = "Password changed successfull" }, JsonRequestBehavior.AllowGet));
            }
            catch (Exception ex)
            {
                return(Json(new { Result = "Error", Message = ex.Message }, JsonRequestBehavior.AllowGet));
            }
        }
        public ActionResult ChangePassword(PasswordChangeViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user       = _repositoryServices.GetUserByName(User.Identity.Name);
                var aspNetUser = user.AspNetUser;

                UserManager.RemovePassword(user.ASPNetUserId);

                UserManager.AddPassword(user.ASPNetUserId, model.Password);
                return(View("Success"));
            }

            return(View(model));
        }
Exemple #5
0
        public async Task <ActionResult> ResetPasswordCust(RegisterViewModel model)
        {
            // Apply the changes if any to the db
            try
            {
                UserManager <IdentityUser> userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>());

                userManager.RemovePassword(model.idx);

                userManager.AddPassword(model.idx, model.Password);
                return(RedirectToAction("ListOfUsers", "Account"));
            }
            catch (Exception e)
            {
                ViewBag.e          = e.Message;
                ViewBag.EmployeeId = new SelectList(db.Employees.OrderBy(s => s.Name), "EmployeeId", "Name");
                //User role
                ViewBag.RolesName = new SelectList(db.Roles.Where(u => !u.Name.Contains("Admin"))
                                                   .ToList(), "Name", "Name");

                //User role
                ViewBag.Name = new SelectList(db.Roles.Where(u => !u.Name.Contains("Admin"))
                                              .ToList(), "Name", "Name");
                return(View(model));
            }
        }
Exemple #6
0
        public ActionResult ChangePassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var store          = new UserStore <ApplicationUser>(new ApplicationDbContext());
            var manager        = new UserManager <ApplicationUser>(store);
            var currentUser    = manager.FindByName(model.Login);
            var removePassword = UserManager.RemovePassword(currentUser.Id);

            if (removePassword.Succeeded)
            {
                //Removed Password Success
                var AddPassword = UserManager.AddPassword(currentUser.Id, model.Password);
                if (AddPassword.Succeeded)
                {
                    return(RedirectToAction("Index", "Account"));
                }
            }

            ModelState.AddModelError("", "Wystąpiły błędy przy zapisie");
            return(View(model));
        }
Exemple #7
0
        public static async Task PasswordRecovery(string email)
        {
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
            var userASP     = userManager.FindByEmail(email);

            if (userASP == null)
            {
                return;
            }

            var user = dbContext.Users.Where(x => x.UserName == email).FirstOrDefault();

            if (user == null)
            {
                return;
            }

            var random      = new Random();
            var newPassword = string.Format("{0}{1}{2:04}*",
                                            user.FirstName.Trim().ToUpper().Substring(0, 1),
                                            user.LastName.Trim().ToLower(),
                                            random.Next(10000));

            userManager.RemovePassword(userASP.Id);
            userManager.AddPassword(userASP.Id, newPassword);

            var subject = "Taxes Password Recovery";
            var body    = string.Format(@"
                    <h1>Taxes Password RECOVERY</h1>
                    <p>You new pass is: <em>{0}</em></p>
                    <p>Please change it for onother</p>", newPassword);

            await MailHelper.SendMail(email, subject, body);
        }
Exemple #8
0
        private static void CreateUpdateUser(UserManager <ErasmusUser> manager, string email, string username, string role, int?uniId = null)
        {
            //Check for existing user
            var user = manager.Users.SingleOrDefault(x => x.Email == email);

            if (user == null)
            {
                //Doesn't exist - create
                user = new ErasmusUser
                {
                    Email        = email, UserName = username, EmailConfirmed = true,
                    Birthday     = new DateTime(1990, 1, 1),
                    UniversityId = uniId
                };
                manager.Create(user, "Slaptaþodis1");
                manager.AddToRole(user.Id, role);
            }
            else
            {
                //Exists update
                user.UserName       = username;
                user.EmailConfirmed = true;
                manager.RemovePassword(user.Id);
                manager.AddPassword(user.Id, "Slaptaþodis1");
                manager.Update(user);
                manager.RemoveFromRoles(user.Id, UserRoles.AllRoles);
                manager.AddToRole(user.Id, role);
            }
        }
Exemple #9
0
        public ActionResult ChangePassword(UserUpdatePassViewModel _userProfileModel)
        {
            if (ModelState.IsValid)
            {
                var userId = _userProfileModel.userId;

                if (UserManager.CheckPassword(UserManager.FindById(userId), _userProfileModel.oldPass))
                {
                    if (_userProfileModel.newPass == _userProfileModel.confirmnewPass)
                    {
                        UserManager.RemovePassword(userId);
                        UserManager.AddPassword(userId, _userProfileModel.newPass);

                        var _url = Url.Action("ChangePassPartialView", "Account", new { user_id = userId });

                        return(Json(new { success = true, url = _url }, JsonRequestBehavior.AllowGet));
                    }
                    else
                    {
                        return(Json(new { success = false, errmsg = "invalid password confirmation" },
                                    JsonRequestBehavior.AllowGet));
                    }
                }
                else
                {
                    return(Json(new { success = false }, JsonRequestBehavior.AllowGet));
                }
            }
            return(Json(new { success = false }, JsonRequestBehavior.AllowGet));
        }
        public async Task <ActionResult> ForgetPassword(ForgetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByNameAsync(model.UserName);

                if (user != null)
                {
                    UserManager.RemovePassword(user.Id);
                    IdentityResult result = await UserManager.AddPasswordAsync(user.Id, model.NewPassword);

                    if (result.Succeeded)
                    {
                        return(RedirectToAction("Login"));
                    }
                    else
                    {
                        AddErrors(result);
                    }
                }
                else
                {
                    ModelState.AddModelError("", "使用者名稱不存在。");
                }
            }

            return(View(model));
        }
Exemple #11
0
        public void ChangePassword(string userId, string password)
        {
            var ManageUser = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));

            ManageUser.RemovePassword(userId);
            ManageUser.AddPassword(userId, password);
        }
Exemple #12
0
        /// <summary>
        /// Metodo que hace la creacion del usuario ASP
        /// </summary>
        /// <param name="email">String que almacena el email</param>
        /// <param name="roleName">String que almacena el role (Admin - User)</param>
        public static void CreateUserASP(string email, string roleName)
        {
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));

            //  CHEJ - Vaida si ya existe el usuario
            var userASP = userManager.FindByEmail(email);

            //var userASP = new ApplicationUser
            //{
            //    Email = email,
            //    UserName = email,
            //};
            if (userASP == null)
            {
                userASP = new ApplicationUser
                {
                    Email    = email,
                    UserName = email,
                };
                //  CHEJ - Crea el usuario ASP
                userManager.Create(userASP, email);
            }
            else
            {
                userManager.RemovePassword(userASP.Id);
                userManager.AddPassword(userASP.Id, userASP.Email);
            }

            //  CHEJ - Le asigna el rol ASP al usuario
            userManager.AddToRole(userASP.Id, roleName);
        }
        public ActionResult ResetPassword(string EmailId = null, string NewPassword = null, string ConfirmPass = null)
        {
            string result = null;

            if (NewPassword == ConfirmPass)
            {
                var user = cus.GetUserDetailByEmail(EmailId);
                if (user != null)
                {
                    var removePassword = UserManager.RemovePassword(user.id);
                    if (removePassword.Succeeded)
                    {
                        //Removed Password Success
                        var AddPassword = UserManager.AddPassword(user.id, NewPassword);
                        if (AddPassword.Succeeded)
                        {
                            result = "Done";
                        }
                    }
                    else
                    {
                        result = "Wrong";
                    }
                }
            }
            else
            {
                result = "NotMatch";
            }
            return(Json(result, JsonRequestBehavior.AllowGet));
        }
        public async Task <IHttpActionResult> ResetPassword(SetPasswordBindingModelCustom model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            IdentityUser user = await UserManager.FindByEmailAsync(model.Email);

            if (user == null)
            {
                return(NotFound());
            }

            UserManager.RemovePassword(user.Id);

            IdentityResult result = await UserManager.AddPasswordAsync(user.Id, model.NewPassword);

            if (!result.Succeeded)
            {
                return(GetErrorResult(result));
            }

            return(Ok());
        }
Exemple #15
0
        public ActionResult ResetPassword(int id, PatientPasswordViewModel viewModel)
        {
            var patient = BVSBusinessServices.Patients.GetByID(id);

            ApplicationDbContext context = new ApplicationDbContext();

            var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));

            var user   = userManager.FindById(patient.MembershipProviderUserID);
            var result = userManager.RemovePassword(user.Id);

            if (result.Succeeded)
            {
                result = userManager.AddPassword(user.Id, viewModel.NewPassword);
            }

            if (result.Succeeded)
            {
                return(RedirectToAction("Details", new { id = id }));
            }
            else
            {
                ModelState.AddModelError("Password", String.Format("Unable to change password. {0}", String.Join(", ", result.Errors)));
                return(View());
            }
        }
Exemple #16
0
        public static async Task ChangePassword(string email, string newPassword)
        {
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
            var userASP     = userManager.FindByEmail(email);

            if (userASP == null)
            {
                return;
            }

            var user = db.Usuarios.Where(tp => tp.NombreUsuario == email).FirstOrDefault();

            if (user == null)
            {
                return;
            }


            userManager.RemovePassword(userASP.Id);
            userManager.AddPassword(userASP.Id, newPassword);

            var subject = "Nuevo Password";
            var body    = string.Format(@"
                <h1>Nuevo Password</h1>
                <p>El usuario: <strong>{1}</strong>, ha cambiado su password: <strong>{0}</strong></p>",
                                        newPassword, email);

            await MailHelper.SendMail(email, "*****@*****.**", subject, body);
        }
Exemple #17
0
        public void UpdateUserById(string Id, string UserName, string PasswordHash, bool Admin)
        {
            using (var um = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()))) {
                var user = um.FindById(Id);
                user.UserName = UserName;
                user.Email    = UserName;
                um.Update(user);
                if (!user.PasswordHash.Equals(PasswordHash))
                {
                    um.RemovePassword(Id);

                    um.AddPassword(Id, PasswordHash);
                }
                if (Admin)
                {
                    if (!um.IsInRole(Id, "Admin"))
                    {
                        um.AddToRole(Id, "Admin");
                    }
                }
                else
                {
                    if (um.IsInRole(Id, "Admin"))
                    {
                        um.RemoveFromRole(Id, "Admin");
                    }
                }
            }
        }
        public ActionResult Edit([Bind(Include = "Email,Password,UserName")] User user)
        {
            if (ModelState.IsValid)
            {
                if (user.Password != null && user.Password != "")
                {
                    var    userManager = new UserManager <User>(new UserStore <User>(db));
                    string user_id     = user.Id.ToString();
                    var    usr         = db.Users.Single(u => u.UserName == user.UserName);

                    var res = userManager.RemovePassword(usr.Id);
                    if (res.Succeeded)
                    {
                        res = userManager.AddPassword(usr.Id, user.Password);
                        if (!res.Succeeded)
                        {
                            AddErrors(res);
                            return(View(user));
                        }
                    }
                }
                //db.Entry(user).State = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }
            return(View(user));
        }
        public static async Task PasswordRecovery(string email)
        {
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
            var UserASP     = userManager.FindByEmail(email);

            if (UserASP == null)
            {
                return;
            }
            var user = db.Users.Where(tp => tp.UserName == email).FirstOrDefault();

            if (user == null)
            {
                return;
            }
            var random      = new Random();
            var newPassword = $"{user.FirstName.Trim().Substring(0, 1).ToUpper()}{user.LastName.Trim().ToLower()}{random.Next(10000):04}*";

            userManager.RemovePassword(UserASP.Id);
            userManager.AddPassword(UserASP.Id, newPassword);

            var subject = "Taxes Password Recovery";
            var body    = $"<h1>{subject}</h1><p>Your new Password: <strong>{newPassword}</strong></p>"
                          + "<p>Please change it for one,that you remeber easyly</p>";

            await SendMail(email, subject, body);
        }
        public ActionResult ChangePass(string id)
        {
            var AccountInDB = _context.Users.SingleOrDefault(p => p.Id == id);

            if (AccountInDB == null)
            {
                return(HttpNotFound());
            }

            //Khai báo biến var userId thuộc Curent.User.Identity và truy cập vào trường Id thông qua GetUserId
            var userId = System.Web.HttpContext.Current.User.Identity.GetUserId();

            userId = AccountInDB.Id;
            if (userId != null)             //Nếu userId tồn tại
            {
                //userManager bằng quản lý người dùng mới, mang dữ liệu mới
                UserManager <IdentityUser> userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>());
                //Xoá password hiện tại của userManager
                userManager.RemovePassword(userId);
                //Thay password mới "123456789" cho userManager
                String newPassword = "******";
                userManager.AddPassword(userId, newPassword);
            }
            _context.SaveChanges();
            return(RedirectToAction("Index"));
        }
Exemple #21
0
        public async Task <IHttpActionResult> ForgetPassword(string email)
        {
            if (string.IsNullOrWhiteSpace(email))
            {
                return(BadRequest("Forneça um e-mail"));
            }

            var user = await UserManager.FindByEmailAsync(email);

            if (user == null)
            {
                return(BadRequest("O usuário não existe"));
            }

            string newPassword = GenerateNewPassword();



            string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);

            UserManager.RemovePassword(user.Id);
            IdentityResult result = await UserManager.AddPasswordAsync(user.Id, newPassword);

            if (!result.Succeeded)
            {
                return(GetErrorResult(result));
            }

            SmtpClient client = new SmtpClient("smtp-mail.outlook.com");

            client.Port                  = 587;
            client.DeliveryMethod        = SmtpDeliveryMethod.Network;
            client.UseDefaultCredentials = false;
            System.Net.NetworkCredential credentials =
                new System.Net.NetworkCredential("*****@*****.**", "Evobooks");
            client.EnableSsl   = true;
            client.Credentials = credentials;

            try
            {
                var mail = new MailMessage("*****@*****.**", email.Trim());
                mail.Subject = "Mudança de senha - Evobooks";
                mail.Body    = @"Olá,

                Sua senha foi modificada com sucesso. Utilize a seguinte senha para logar apartir de agora:

                " + newPassword + @"

                Atenciosamente,

                Equipe Evobooks";

                client.Send(mail);
                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public bool ResetPassword(string passwordResetToken, string newPassword)
        {
            string userId = GetUserIdFromPasswordToken(passwordResetToken);

            if (string.IsNullOrEmpty(userId))
            {
                return(false);
            }
            //We have to remove the password before we can add it.
            IdentityResult result = UserManager.RemovePassword(userId);

            if (!result.Succeeded)
            {
                return(false);
            }
            //We have to add it because we do not have the old password to change it.
            result = UserManager.AddPassword(userId, newPassword);
            if (!result.Succeeded)
            {
                return(false);
            }

            //Lets remove the token so it cannot be used again.
            RemovePasswordToken(userId);
            //TODO: Should use a timestamp on the token so the reset will not work after a set time.
            return(true);
        }
Exemple #23
0
        // PUT api/values/5
        public HttpResponseMessage Put(Guid id, [FromBody] UserViewModel model)
        {
            var user = UserManager.FindById(id);

            if (id == model.Id)
            {
                user.UserName  = model.UserName;
                user.FirstName = model.FirstName;
                user.LastName  = model.LastName;
                user.Email     = model.Email;
                UserManager.Update(user);
                if (!string.IsNullOrEmpty(model.Password))
                {
                    UserManager.RemovePassword(id);
                    UserManager.AddPassword(id, model.Password);
                }
                var role = UserManager.GetRoles(id).FirstOrDefault();
                if (model.Type == UserType.Administrator && role == Consts.CustomerRole)
                {
                    UserManager.RemoveFromRole(id, Consts.CustomerRole);
                    UserManager.AddToRole(id, Consts.AdministratorRole);
                }
                else if (model.Type == UserType.Customer && role == Consts.AdministratorRole)
                {
                    UserManager.RemoveFromRole(id, Consts.AdministratorRole);
                    UserManager.AddToRole(id, Consts.CustomerRole);
                }
            }
            return(new HttpResponseMessage(HttpStatusCode.NoContent));
        }
        public Tuple <User, bool> UpdateUser(User model, string newPassword = null)
        {
            var succeeded = true;
            var prevUser  = _context.Users.Find(model.Id);

            _context.Entry(prevUser).State = EntityState.Detached;
            _context.Entry(model).State    = EntityState.Modified;
            _context.SaveChanges();
            //_userManager.Update(model);
            if (!string.IsNullOrEmpty(newPassword))
            {
                var userPrevPassword = model.PasswordHash; // keeping prev password just in case setting new password fails
                var removePassword   = _userManager.RemovePassword(model.Id);
                if (removePassword.Succeeded)
                {
                    var addPassword = _userManager.AddPassword(model.Id, newPassword);
                    if (addPassword.Succeeded == false)
                    {
                        succeeded                   = false;
                        model.PasswordHash          = userPrevPassword;
                        _context.Entry(model).State = EntityState.Modified;
                        _context.SaveChanges();
                        //_userManager.Update(model);
                    }
                }
            }
            var updateModel = new Tuple <User, bool>(model, succeeded);

            return(updateModel);
        }
        private ExpandedUserDTO UpdateDTOUser(ExpandedUserDTO paramExpandedUserDTO)
        {
            ApplicationUser result = UserManager.FindByName(paramExpandedUserDTO.UserName);

            //If we could not find the user, throw an exception
            if (result == null)
            {
                throw new Exception("Could not find the User");
            }
            result.Email = paramExpandedUserDTO.Email;

            //Lets check if the account needs to be unlocked]
            if (UserManager.IsLockedOut(result.Id))
            {
                //Unlock User
                UserManager.ResetAccessFailedCountAsync(result.Id);
            }
            UserManager.Update(result);
            //Was a password sent across?
            if (!string.IsNullOrEmpty(paramExpandedUserDTO.Password))
            {
                //remove current password
                var removePassword = UserManager.RemovePassword(result.Id);
                if (removePassword.Succeeded)
                {
                    //add new password
                    var AddPassword = UserManager.AddPassword(result.Id, paramExpandedUserDTO.Password);
                    if (AddPassword.Errors.Count() > 0)
                    {
                        throw new Exception(AddPassword.Errors.FirstOrDefault());
                    }
                }
            }
            return(paramExpandedUserDTO);
        }
Exemple #26
0
        public static async Task PasswordRecovery(string email)
        {
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
            var userASP     = userManager.FindByEmail(email);

            if (userASP == null)
            {
                return;
            }

            var user = db.Taxpayers.Where(tp => tp.UserName == email).FirstOrDefault();

            if (user == null)
            {
                return;
            }

            var random      = new Random();
            var newPassword = string.Format("{0}{1}{2:04}*",
                                            user.FirstName.Trim().ToUpper().Substring(0, 1),
                                            user.LastName.Trim().ToLower(),
                                            random.Next(10000));

            userManager.RemovePassword(userASP.Id);
            userManager.AddPassword(userASP.Id, newPassword);

            var subject = "Taxes Password Recovery";
            var body    = string.Format(@"
        <h1>Taxes Password Recovery</h1>
        <p>Yor new password is: <strong>{0}</strong></p>
        <p>Please change it for one, that you remember easyly",
                                        newPassword);

            await SendMail(email, subject, body);
        }
Exemple #27
0
        public bool ResetPassword(string userId, string newPass, out string message)
        {
            var unitOW = IoC.Resolve <IUnitOfWork>();

            try
            {
                var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(unitOW.DbContext));
                unitOW.BeginTran();
                var success = manager.RemovePassword(userId);
                if (success.Succeeded)
                {
                    var s = manager.AddPassword(userId, newPass);
                    if (s.Succeeded)
                    {
                        unitOW.CommitTran();
                        message = "Đổi mật khẩu thành công.";
                        return(true);
                    }
                }
                unitOW.RollbackTran();
                message = "Đổi mật khẩu thất bại.";
                return(false);
            }
            catch (Exception ex)
            {
                unitOW.RollbackTran();
                log.Error(ex);
                message = ex.Message;
                return(false);
            }
        }
Exemple #28
0
 protected void SetPassword_Click(object sender, EventArgs e)
 {
     if (IsValid)
     {
         var id = Request.QueryString["ID"];
         if (id != null)
         {
             // Create the local login info and link the local account to the user
             UserManager    manager = new UserManager();
             IdentityResult result1 = manager.RemovePassword(id);
             IdentityResult result  = manager.AddPassword(id, password.Text);
             if (result.Succeeded)
             {
                 lblMessage.Text = "Passward Changed Successfully";
             }
             else
             {
                 foreach (var error in result.Errors)
                 {
                     lblMessage.Text += "" + error;
                 }
                 //lblMessage.Text = result.Errors.ToString();
             }
         }
     }
 }
Exemple #29
0
            public static async Task PasswordRecovery(string email)
            {
                var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
                var userASP     = userManager.FindByEmail(email);

                if (userASP == null)
                {
                    return;
                }

                var user = db.pessoas.Where(tp => tp.Email == email).FirstOrDefault();

                if (user == null)
                {
                    return;
                }

                var random      = new Random();
                var newPassword = string.Format("{0}{1}{2:04}*",
                                                user.NomePessoa.Trim().ToUpper().Substring(0, 1),
                                                user.NomePessoa.Trim().ToLower(),
                                                random.Next(10000));

                userManager.RemovePassword(userASP.Id);
                userManager.AddPassword(userASP.Id, newPassword);

                var subject = "A senha foi modificada";
                var body    = string.Format(@"
                <h1>A senha foi modificada</h1>
                <p>Sua nova senha é: <strong>{0}</strong></p>
                <p>Sua senha foi alterada com sucesso",
                                            newPassword);

                await MailHelpers.SendMail(email, subject, body);
            }
Exemple #30
0
        public async Task <ActionResult> UpdateUserPasswordAsync(UserSecurityViewModel userSecurityViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(PartialView("_ChangeUserPassword", userSecurityViewModel));
            }

            var userId = userSecurityViewModel.userId;

            if (await UserManager.CheckPasswordAsync(UserManager.FindById(userId), userSecurityViewModel.oldPass))
            {
                if (userSecurityViewModel.newPass == userSecurityViewModel.confirmnewPass)
                {
                    UserManager.RemovePassword(userId);
                    UserManager.AddPassword(userId, userSecurityViewModel.newPass);


                    return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
                }
                else
                {
                    return(Json(new { success = false, errmsg = "invalid password confirmation" },
                                JsonRequestBehavior.AllowGet));
                }
            }
            else
            {
                return(Json(new { success = false, errmsg = "Current password invalid" },
                            JsonRequestBehavior.AllowGet));
            }
        }
Exemple #31
0
        protected void Recover_Click(object sender, EventArgs e)
        {
            String user = User.Text;
            String email = Email.Text;
            if (user != "" && email != "")
            {

                ApplicationDbContext context = new ApplicationDbContext();
                String idUser = SqlCode.SelectForString("select id from AspNetUsers where UserName = '******'");
                ApplicationUser userr = context.Users.Find(idUser);

                if (userr.IsNotNull())
                {
                    if (userr.Email == email)
                    {
                        //gets user manager
                        UserManager manager = new UserManager();
                        //removes user pass
                        IdentityResult result = manager.RemovePassword(idUser);
                        //generates new pass
                        String newPass = (Guid.NewGuid().ToString("N").Substring(1, 8) + ".").Trim();
                        //updates the pass
                        result = manager.AddPassword(idUser, newPass);

                        if (result.Succeeded)
                        {
                            EmailClass.SendEmailRecover(email, newPass);
                            PlaceHolder1.Visible = true;
                            FailureText.Text = "Password of user changed email has been send";
                            Thread.Sleep(1000);
                            Response.Redirect("~/Account/Login.aspx");

                        }
                        else
                        {
                            PlaceHolder1.Visible = true;
                            FailureText.Text = "Error reseting the password";
                        }

                    }
                    else
                    {
                        PlaceHolder1.Visible = true;
                        FailureText.Text = "User does not match email!!";
                    }
                }
                else
                {
                    PlaceHolder1.Visible = true;
                    FailureText.Text = "User is invalid";
                }

            }
            else
            {
                PlaceHolder1.Visible = true;
                FailureText.Text = "User or password fields are empty!!";
            }
        }
        public ActionResult ResetPassword(ResetPasswordViewModel model)
        {
            var um = new UserManager<ApplicationUser>(
                new UserStore<ApplicationUser>(new ApplicationDbContext()));
            string userId = um.FindByName(model.UserName).Id;
            bool hasPassword = HasPassword(userId);
            ViewBag.HasLocalPassword = hasPassword;
            ViewBag.ReturnUrl = Url.Action("ResetPassword");
            if (hasPassword)
            {
                if (ModelState.IsValid)
                {
                    //IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
                    IdentityResult result = um.RemovePassword(userId);
                    if (result.Succeeded)
                    {
                        result = um.AddPassword(userId, model.NewPassword);
                        if (result.Succeeded)
                        {
                            return RedirectToAction("ResetPassword", new
                            {
                                Message = ManageMessageId.ChangePasswordSuccess
                               ,
                                userName = model.UserName
                            });
                        }
                        else
                        {
                            AddErrors(result);
                        }
                    }
                    else
                    {
                        AddErrors(result);
                    }
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
Exemple #33
0
        public JsonResult ChangeUserPassword(string userId, string password)
        {
            UserManager<IdentityUser> userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>());
            userManager.RemovePassword(userId);
            userManager.AddPassword(userId, password);

            return Json(new { success = true });
        }
        public ActionResult Rights_User_SetPassword(SetUserPasswordViewModel model)
        {
            ModelState state = ModelState["NewPassword"];

            if (ModelState.IsValid)
            {
                var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(_identityDb));
                userManager.UserValidator = new UserValidator<ApplicationUser>(userManager) { AllowOnlyAlphanumericUserNames = false };
                
                var result2 = userManager.RemovePassword(model.userId);
                var result = userManager.AddPassword(model.userId, model.NewPassword);
                return RedirectToAction("Rights");
            }

            return View();
        }
Exemple #35
0
        public ActionResult ResetPassword(FormCollection coll)
        {                    
            string[] randomAdjectives = {"thrutinn", "sleipur", "lodinn", "bonadur", "gradur", "brundadur", "siginn",
                                    "risinn", "lepjandi", "litill", "stor", "langur", "stuttur", "stinnur"};
            string[] randomNouns = {"angus", "besefi", "brusi", "lokur", "redur", "skondull", "tilli", "volsi", "skaufi"};

            var rand = new Random();
            int adjectiveNumber = rand.Next(0, 13);
            int nounNumber = rand.Next(0, 8);
            int randomNumber = rand.Next(1, 999);

            string newPass = randomAdjectives[adjectiveNumber] + randomNouns[nounNumber] + randomNumber.ToString();

            var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>());            
            var userService = new UserService();
            var email = coll["Email"];
            if(userService.getUserByEmail(email) != null)
            {
                var userId = userService.getUserByEmail(email).Id;
                userManager.RemovePassword(userId);
                userManager.AddPassword(userId, newPass);
                var message = new MailMessage();
                message.To.Add(new MailAddress(email));
                message.From = new MailAddress("Skilaboðaskjóðan");
                message.Subject = "Your password has been reset. ";
                message.Body = "<h2>Your password was reset on " + DateTime.Now.ToString() + "</h2>" + "<h3>Your new password is: " + newPass + "</h2>";
                message.IsBodyHtml = true;
                var smtp = new SmtpClient();

                var credential = new NetworkCredential
                {
                    UserName = "******",
                    Password = "******"
                };
                smtp.Credentials = credential;
                smtp.Host = "smtp.gmail.com";
                smtp.Port = 587;
                smtp.EnableSsl = true;
                smtp.Send(message);
            }        
            return Redirect(HttpContext.Request.UrlReferrer.AbsoluteUri);
        
        }
        protected void usersListview_ItemCommand(object sender, ListViewCommandEventArgs e)
        {
            if (e.CommandName == "SaveUserRoles")
            {
                string userId = e.CommandArgument.ConvertTo<string>();
                UserManager manager = new UserManager();
                CheckBoxList userRolesCheckboxList = e.Item.FindFirstControl<CheckBoxList>("userRolesCheckboxList");
                foreach (ListItem item in userRolesCheckboxList.Items)
                {
                    if (item.Selected)
                    {
                        manager.AddToRole(userId, item.Text);
                    }
                    else
                    {
                        manager.RemoveFromRole(userId, item.Text);
                    }
                }
                SuccessMessageUser = "******";
                successMessageUser.Visible = true;
            }
            else if (e.CommandName == "ChangePassword")
            {
                TextBox passwordTextBox = e.Item.FindFirstControl<TextBox>("NewPassword");
                TextBox confirmPasswordTextBox = e.Item.FindFirstControl<TextBox>("ConfirmNewPassword");

                if (!passwordTextBox.Equals("") && !confirmPasswordTextBox.Equals("") &&
                    passwordTextBox.Text == confirmPasswordTextBox.Text)
                {
                    string userId = e.CommandArgument.ConvertTo<string>();
                    UserManager manager = new UserManager();
                    IdentityResult result = manager.RemovePassword(userId);
                    result = manager.AddPassword(userId, passwordTextBox.Text);
                    if (result.Succeeded)
                    {
                        successMessageUser.Visible = true;
                        SuccessMessageUser = "******";
                    }
                    else
                    {
                        successMessageUser.Visible = true;
                        AddErrors(result);
                        return;
                    }
                }
            }
        }
Exemple #37
0
        public ActionResult Edit(EditAccountModel editModel)
        {
            var userManager = new UserManager<Account>(new UserStore<Account>(DbContext));
            Account editAccount = userManager.FindByName(editModel.UserName);

            if (editAccount == null)
            {
                return RedirectErrorPage();
            }

            // Kiểm tra tên tài khoản đã tồn tại hay chưa
            Account accountDb;
            if (editAccount.UserName != editModel.UserName)
            {
                accountDb = userManager.FindByName(editModel.UserName);
                if (accountDb != null)
                {
                    ModelState.AddModelError("UserName", "Tên tài khoản đã được sử dụng.");
                }
            }

            if (editAccount.Email != editModel.Email)
            {
                accountDb = userManager.FindByEmail(editModel.Email);
                if (accountDb != null)
                {
                    ModelState.AddModelError("Email", "Email đã được sử dụng.");
                }
            }
            if (editAccount.Profile.Identity != editModel.Identity)
            {
                accountDb = DbContext.Accounts.FirstOrDefault(s => s.Profile.Identity == editModel.Identity);
                if (accountDb != null)
                {
                    ModelState.AddModelError("Identity", "Mã số này đã được sử dụng.");
                }
            }

            if (ModelState.IsValid)
            {
                try
                {
                    var acc = userManager.FindByName(editModel.UserName);
                    acc.Email = editModel.Email;
                    acc.PhoneNumber = editModel.PhoneNumber;
                    acc.Profile.BirthDate = editModel.BirthDate;
                    acc.Profile.FirstName = editModel.FirstName;
                    acc.Profile.LastName = editModel.LastName;
                    acc.Profile.Notes = editModel.Notes;
                    acc.Profile.Actived = editModel.Actived;
                    acc.Profile.Identity = editModel.Identity;
                    var result = userManager.Update(acc);
                    if (result.Succeeded)
                    {
                        if (!string.IsNullOrEmpty(editModel.Password))
                        {
                            userManager.RemovePassword(acc.Id);
                            userManager.AddPassword(acc.Id, editModel.Password);
                        }
                        if (editModel.Role == "Admin")
                        {
                            userManager.AddToRole(acc.Id, "Admin");
                            userManager.AddToRole(acc.Id, "Teacher");
                        }
                        else if (editModel.Role == "Teacher")
                        {
                            userManager.AddToRole(acc.Id, "Teacher");
                        }
                        else
                        {
                            userManager.AddToRole(acc.Id, "Student");
                        }

                        return Redirect(null);
                    }
                    ModelState.AddModelError("", "Đã có lỗi xảy ra. Vui lòng thử lại sau.");
                }
                catch
                {
                    ModelState.AddModelError("", "Đã có lỗi xảy ra. Vui lòng thử lại sau.");
                }
            }
            ViewBag.IsEdit = true;
            InitFormData(editModel);
            return View(editModel);
        }