Exemple #1
0
        public ActionResult ChangePassword(int?id)
        {
            if (!User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Login", "Account"));
            }

            var existingUser = db.Users.FirstOrDefault(u => u.Mail == User.Identity.Name);
            var changePass   = new ChangePass {
                Id = existingUser.Id, Mail = existingUser.Mail
            };

            if (id == existingUser.Id)
            {
                return(View(changePass));
            }

            else if (id == null)
            {
                return(RedirectToAction("Login", "Account"));
            }

            else
            {
                RedirectToAction("Index", "Home");
            }

            return(RedirectToAction("Details", "Account"));
        }
Exemple #2
0
        public ActionResult Change(ChangePass changePass)
        {
            if (HttpContext.Session["login"] == null)
            {
                return(Redirect("~"));
            }

            if (ModelState.IsValid)
            {
                // check password
                Account account = new Account();
                account.Login = Session["login"].ToString();
                Link.GetUser(account);
                if (account.Password == Request.Form["oldpassword"].ToString())
                {
                    // сохраняем
                    account.Password = Request.Form["newpassword"].ToString();
                    if (Link.EditUser(account))
                    {
                        ViewBag.Success = "Данные сохранены";
                    }
                    else
                    {
                        ViewBag.Error = "Ошибка записи в базу данных";
                    }
                }
                else
                {
                    ModelState.AddModelError("oldpassword", "Не верный пароль");
                }
            }

            return(View());
        }
Exemple #3
0
        public bool ChangePassword(ChangePass newPass, out string message)
        {
            var user = database.Uzytkownik.Single(x => x.id == newPass.userID && x.password == newPass.oldPassword);

            if (user == null)
            {
                message = "Wrong login or password!";
                return(false);
            }
            string session     = GenerateSessionID(user.login);
            var    mailAddress = new MailAddress(user.email, user.login);
            var    result      = provider.SendChangePasswordEmail(mailAddress, session);

            if (result == "Success!")
            {
                user.password = newPass.newPassword;
                var confirm = new Uzytkownik_Potwierdzenie()
                {
                    id = database.Uzytkownik_Potwierdzenie.Max(x => x.id) + 1,
                    generatedLinkHash = session,
                    uzytkownik_id     = user.id
                };
                database.Uzytkownik_Potwierdzenie.Add(confirm);
                database.SaveChanges();
                message = "Password was changed";
                return(true);
            }
            message = "Ops! Something went wrong. Password didn't changed\n" + result;
            return(false);
        }
Exemple #4
0
        public ActionResult Change(ChangePass changePass)
        {
            if (ModelState.IsValid)
            {
                int id;
                Int32.TryParse(Session["loginid"].ToString(), out id);
                Account account = Link.Accounts.Get(id);
                if (account.Password == Request.Form["oldpassword"].ToString())
                {
                    account.Password = Request.Form["newpassword"].ToString();
                    bool success = false;
                    try
                    {
                        Link.Accounts.Update(account);
                        Link.Save();
                        success = true;
                    }
                    catch
                    {
                        // логирование
                    }
                    ViewShowMessage(success, "Данные сохранены", "Ошибка записи в базу данных");
                }
                else
                {
                    ModelState.AddModelError("oldpassword", "Не верный пароль");
                }
            }

            return(View());
        }
 public ActionResult ChangePassword(ChangePass model)
 {
     if (string.IsNullOrEmpty(model.NewPassWord))
     {
         ModelState.AddModelError("NewPassWord", "NewPassWord Expected");
     }
     if (string.IsNullOrEmpty(model.EnterAgain))
     {
         ModelState.AddModelError("EnterAgain", "EnterAgain Expected");
     }
     if (model.OldPassWord == model.NewPassWord)
     {
         ModelState.AddModelError("NewPassWord", "The new password must not be the same as the old password");
     }
     if (model.NewPassWord != model.EnterAgain)
     {
         ModelState.AddModelError("EnterAgain", "Password do not match");
     }
     if (!ModelState.IsValid)
     {
         ViewBag.Title = "ChangePassword";
         return(View(model));
     }
     if (model.EmployeeID != 0)
     {
         CatalogBLL.UpdatePass(model);
         if (!CatalogBLL.UpdatePass(model))
         {
             return(RedirectToAction("ChangePassword"));
         }
     }
     return(RedirectToAction("Index"));
 }
Exemple #6
0
        public async Task <IActionResult> OnPostPasswordFormAsync(ChangePass NewPassword)
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }
            var user = _userService.GetByEmail(NewPassword.Email);

            try
            {
                //save user
                if (user != null)
                {
                    _userService.Update(user.ID, NewPassword.Password);
                    TempData[MessageKey] = "Şifre Değiştirildi";
                    HttpContext.Session.Clear();
                }
                else
                {
                    TempData[MessageKey] = "Kullanıcı Bulunamadı";
                }
                return(Redirect("/forms/loginform"));
            }
            catch (AppException ex)
            {
                TempData[MessageKey] = "Şifre Değiştirirken Hata Oluştu";
                return(RedirectToAction(Request.Path));
            }
        }
        //generate new password and send it to user's email
        public async Task <string> PasswordReset(ChangePass email)
        {
            var isUserExists = await _accountRepository.CheckExistingEmail(email.Email);

            if (isUserExists)
            {
                string generatedPass = CreateRandomPassword();
                string encryptPass   = EncryptPassword(generatedPass);

                UserAccounts userAccounts = new UserAccounts
                {
                    Id        = (await _accountRepository.GetUserDetailsForPasswordReset(email)).Item7,
                    Username  = (await _accountRepository.GetUserDetailsForPasswordReset(email)).Item3,
                    Email     = (await _accountRepository.GetUserDetailsForPasswordReset(email)).Item1,
                    FullName  = (await _accountRepository.GetUserDetailsForPasswordReset(email)).Item2,
                    RoleID    = (await _accountRepository.GetUserDetailsForPasswordReset(email)).Item4,
                    IsActive  = (await _accountRepository.GetUserDetailsForPasswordReset(email)).Item5,
                    IsChanged = true,
                    Password  = encryptPass,
                    IsDeleted = false
                };

                string emailResponse = SendNewPasswordToEmail(email.Email, generatedPass, userAccounts.Username);

                await _accountRepository.ChangePassword(userAccounts);

                return(emailResponse);
            }
            else
            {
                return("false");
            }
        }
        public async Task <IActionResult> ChangePass(ChangePass changePass)
        {
            if (ModelState.IsValid)
            {
                ApplicationUser user = userManager.FindByIdAsync(changePass.Id).Result;
                if (user != null)
                {
                    var result = await userManager.ChangePasswordAsync(user, changePass.CurrentPassword, changePass.NewPassword);

                    if (result.Succeeded)
                    {
                        await userManager.UpdateAsync(user);

                        return(RedirectToAction("Index", "Home"));
                    }
                    else
                    {
                        ModelState.AddModelError("", "Mật khẩu hiện tại không đúng !");
                    }
                }
                else
                {
                    return(View(changePass));
                }
            }
            return(View(changePass));
        }
Exemple #9
0
        public void ChangePassword(ChangePass data)
        {
            var login = CurrentLogin();
            var now   = DateTime.UtcNow;

            try
            {
                //using (var ctx = new SecurityDatabaseContext(settings["ConnectionStrings:VEFrameworkDb"]))
                {
                    var user = _context.Users.FirstOrDefault(u => u.Login == login);
                    if (user == null)
                    {
                        throw new Exception();
                    }

                    if (!SecurityUtil.VerifyPassword(data.OldPass, user.PasswordHash))
                    {
                        throw new Exception();
                    }

                    user.PasswordHash = SecurityUtil.HashPassword(data.Pass);
                    user.ModifiedBy   = login;
                    user.ModifiedOn   = now;
                    _context.SaveChanges();
                }
            }
            catch
            {
                throw new HttpResponseException(HttpStatusCode.InternalServerError, $"Cannot change password for user '{login}'");
            }
        }
Exemple #10
0
 public ActionResult ChangePass(ChangePass changePass)
 {
     if (ModelState.IsValid)
     {
         if (Session["cp_Login"] != null && Session["cp_Pass"] != null)
         {
             var userPassData = passwordHelper.CryptPassword(changePass.Password);
             userPassData.Login = Session["cp_Login"].ToString();
             try
             {
                 var user = dataHelper.ChangePass(userPassData);
                 if (user != null)
                 {
                     FormsAuthentication.SetAuthCookie(user.Login, true);
                     return(View("PassChangeSuccess"));
                 }
                 else
                 {
                     return(View("Error", new Error()
                     {
                         ExDescription = "Error to find User!"
                     }));
                 }
             }
             catch (ValidationException ve)
             {
                 return(View("UserError", ve));
             }
         }
     }
     return(View(changePass));
 }
        public ChangePass Get(int employeeID)
        {
            ChangePass data = null;

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                SqlCommand cmd = new SqlCommand();
                cmd.CommandText = @"SELECT * FROM Employees WHERE EmployeeID = @employeeID";
                cmd.CommandType = CommandType.Text;
                cmd.Connection  = connection;
                cmd.Parameters.AddWithValue("@employeeID", employeeID);
                using (SqlDataReader dbReader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                {
                    if (dbReader.Read())
                    {
                        data = new ChangePass()
                        {
                            EmployeeID  = Convert.ToInt32(dbReader["EmployeeID"]),
                            Email       = Convert.ToString(dbReader["Email"]),
                            OldPassWord = Convert.ToString(dbReader["Password"]),
                        };
                    }
                }

                connection.Close();
            }

            return(data);
        }
Exemple #12
0
        private void _CHANGE_PASS_OnClick(object sender, RoutedEventArgs e)
        {
            var wind = new ChangePass {
                Owner = GetWindow(this)
            };

            wind.ShowDialog();
        }
        public void PostChangePassword([FromBody] ChangePass cp) //Post to check if phone number exists in database
        {
            FinanceEntities db = new FinanceEntities();

            var query = (from x in db.Users where x.Phoneno == cp.phone select x).FirstOrDefault();

            query.Password = cp.password;
            db.SaveChanges();
        }
Exemple #14
0
        private void Change()
        {
            this.ChangPassUser = cbChangePassword.Text;
            ChangePass pass = new ChangePass(
                this.ChangPassUser
                , this.txtChangePassword.Text
                , this.txtChangePasswordConf.Text);

            pass.Change();
        }
Exemple #15
0
 private void ChangePassword_Click(object sender, EventArgs e)
 {
     if (CheckAndLoadSettings())
     {
         ChangePass cp = new ChangePass();
         cp.MdiParent = this;
         cp.DBPath    = DatabasePath;
         cp.LoginUser = tssUserlogin.Text;
         cp.Show();
     }
 }
        public async Task <IActionResult> PasswordReset([FromBody] ChangePass email)
        {
            var passResetResponse = await _accountService.PasswordReset(email);

            if (passResetResponse == "Success")
            {
                return(Ok(true));
            }
            else
            {
                return(BadRequest(new { message = passResetResponse }));
            }
        }
 public ActionResult ChangePassword(string id = "")
 {
     if (!string.IsNullOrEmpty(id))
     {
         ViewBag.Title = "ChangePassword";
         ChangePass changePass = CatalogBLL.GetEmployeeChange(Convert.ToInt32(id));
         if (changePass != null)
         {
             return(View(changePass));
         }
         return(RedirectToAction("Index"));
     }
     return(RedirectToAction("Index"));
 }
Exemple #18
0
        public ActionResult ChangePassword(ChangePass changePass)
        {
            if (!User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Login", "Account"));
            }

            if (ModelState.IsValid)
            {
                var existingUser = db.Users.FirstOrDefault(u => u.Mail == User.Identity.Name);

                if ((changePass.OldPassword == existingUser.Password) & (changePass.Id == existingUser.Id))
                {
                    if (changePass.NewPassword != changePass.ConfirmNewPassword)
                    {
                        ModelState.AddModelError("NewPassword", "Пароли не совпадают");
                        return(View());
                    }

                    existingUser.Password        = changePass.NewPassword;
                    db.Entry(existingUser).State = EntityState.Modified;
                    try
                    {
                        db.SaveChanges();
                        return(RedirectToAction("Details", "Account"));
                    }
                    catch (DbEntityValidationException ex)
                    {
                        foreach (DbEntityValidationResult validationError in ex.EntityValidationErrors)
                        {
                            Response.Write("Object: " + validationError.Entry.Entity.ToString());
                            Response.Write("    ");
                            foreach (DbValidationError err in validationError.ValidationErrors)
                            {
                                Response.Write(err.ErrorMessage + "    ");
                            }
                        }
                    }


                    return(RedirectToAction("Details", "Account"));
                }

                ModelState.AddModelError("OldPassword", "Неверный пароль");
                return(View());
            }
            //ModelState.AddModelError("NewPassword", "Пароли не совпадают");
            return(View());
        }
Exemple #19
0
        public int ChangePass(ChangePass changePass)
        {
            String oldPass = StringToMd5.GetMd5Hash(changePass.OldPass);
            var    user    = WcDbContext.users.Single(user1 => user1.UserId == changePass.UserId);

            if (user.UserPass == oldPass)
            {
                user.UserPass = StringToMd5.GetMd5Hash(changePass.NewPass);
                var n = WcDbContext.SaveChanges();
                return(n);
            }

            //mật khẩu cũ không khóp
            return(-4);
        }
        public IActionResult ChangePassword([FromBody] ChangePass newPass)
        {
            if (newPass == null)
            {
                return(NullValues());
            }
            string message = null;
            var    result  = userDao.ChangePassword(newPass, out message);

            if (!result)
            {
                return(BadRequest(message));
            }
            return(Ok(message));
        }
        public ActionResult changePassword(ChangePass cp)
        {
            using (NotesMarketplaceEntities DBobj = new NotesMarketplaceEntities())

            {
                int   id = (int)Session["UserID"];
                Users u  = DBobj.Users.Where(x => x.UserID == id).FirstOrDefault();
                if (u.Password == cp.Password)
                {
                    u.Password = cp.NewPassword;
                    DBobj.SaveChanges();
                    ViewBag.PassMessage = "<p><span><i class='fas fa-check-circle'></i></span> Your Password has been Changed successfully</p>";
                }
            }
            return(View());
        }
Exemple #22
0
        public IHttpActionResult PutPatient(int id, ChangePass user)
        {
            var currentUser = db.Users.FirstOrDefault(x => x.Email == this.User.Identity.Name);


            var tmp = db.Users.Find(id);

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

            if (currentUser.UserId != id)
            {
                return(Content(HttpStatusCode.Forbidden, Messages.AccsesDenied));
            }

            if (user.OldPass != tmp.Password)
            {
                return(BadRequest());
            }

            tmp.Password = user.NewPass;


            db.Entry(tmp).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
                return(Ok());
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!PatientExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
Exemple #23
0
        //Lấy lại mật khẩu
        public ResponseInfo ChangePassword(ChangePass data)
        {
            ResponseInfo result = new ResponseInfo();

            try
            {
                string         Token         = BaoMat.Base64Decode(data.tokenReset);
                TblTokenResset resetPassWord = context.ResetPassWords.FirstOrDefault(x => x.TokenReset == Token && !x.DelFlag);
                if (resetPassWord == null)
                {
                    result.Code = 400;
                    var errorMsg = new GetErrorMsg().GetMsg((int)MessageEnum.MsgNO.ThayDoiMatKhauThatBai);
                    result.TypeMsgError = errorMsg.Type;
                    result.MsgError     = errorMsg.Msg;
                }
                else if (resetPassWord.ThoiGianHetHan < DateTime.Now)
                {
                    result.Code = 400;
                    var errorMsg = new GetErrorMsg().GetMsg((int)MessageEnum.MsgNO.TokenResetHetHan);
                    result.TypeMsgError = errorMsg.Type;
                    result.MsgError     = errorMsg.Msg;
                }
                else
                {
                    string Hash_Pass = BaoMat.GetMD5(BaoMat.GetSimpleMD5(data.NewPass), context.TaiKhoans.Where(x => x.Id == resetPassWord.Id_TaiKhoan && !x.DelFlag).FirstOrDefault().salt_Pass);
                    //cập nhật mật khẩu
                    context.TaiKhoans.Where(x => x.Id == resetPassWord.Id_TaiKhoan && !x.DelFlag).Update(y => new TblTaiKhoan
                    {
                        hash_Pass = Hash_Pass
                    });
                    context.ResetPassWords.Where(x => x.TokenReset == Token).Delete();
                    context.ResetPassWords.Where(x => x.ThoiGianHetHan < DateTime.Now).Delete();
                    context.SaveChanges();
                    var errorMsg = new GetErrorMsg().GetMsg((int)MessageEnum.MsgNO.ThayDoiMatKhauThanhCong);
                    result.TypeMsgError = errorMsg.Type;
                    result.MsgError     = errorMsg.Msg;
                    return(result);
                }
                return(result);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Exemple #24
0
        public async Task <int> ChangePassAs(ChangePass changePass)
        {
            user   user    = OneUser(changePass.UserId);
            String oldPass = StringToMd5.GetMd5Hash(changePass.OldPass);

            if (user.UserPass == oldPass)
            {
                user.UserPass = StringToMd5.GetMd5Hash(changePass.NewPass);
                var n = await WcDbContext.SaveChangesAsync();

                return(n);
            }
            else
            {
                //mật khẩu cũ không khóp
                return(-1);
            }
        }
Exemple #25
0
        public ActionResult ChangePassword(ChangePass chPass)//,string id)
        {
            bool isChanged       = false;
            var  findUserByEmail = _usersRepository.GetUserByEmail(chPass.Email);

            if (findUserByEmail != null)
            {
                SendEmail email = new SendEmail();
                email.ChangePasswordEmail(findUserByEmail.Email, findUserByEmail.UniqueCode.ToString());
                ViewBag.Message = "Wysłano, sprawdź swoja skrytkę pocztową";
                isChanged       = true;
            }
            else
            {
                ViewBag.Message = "Podany email jest nieprawidłowy";
            }

            ViewBag.IsChanged = isChanged;
            return(View());
        }
Exemple #26
0
        public ResponseInfo ChangePass(ChangePass data)
        {
            ResponseInfo response = new ResponseInfo();

            try
            {
                response           = new LoginModel().ChangePassword(data);
                response.IsSuccess = true;
                response.IsValid   = true;
            }
            catch (Exception e)
            {
                response.Code = (int)ConstantsEnum.CodeResponse.ServerError;
                var errorMsg = new GetErrorMsg().GetMsg((int)MessageEnum.MsgNO.ServerError);
                response.TypeMsgError    = errorMsg.Type;
                response.MsgError        = errorMsg.Msg;
                response.ThongTinBoSung1 = e.Message;
            }
            return(response);
        }
Exemple #27
0
        public ActionResult ChangePassword(ChangePass changePass)
        {
            if (Session["Email"] != null)
            {
                if (ModelState.IsValid)
                {
                    using (BitBookContext aBitBookContext = new BitBookContext())
                    {
                        var log = aBitBookContext.Users.FirstOrDefault(a => a.Password.Equals(changePass.NewPassword));
                        if (log != null)
                        {
                            Response.Write("<script> alert('You entered same password')</script>");
                        }
                        else
                        {
                            string userEmail = null;
                            userEmail = Session["Email"].ToString();
                            var usr = aBitBookContext.Users.Where(x => x.Email.Equals(userEmail)).FirstOrDefault();

                            usr.Password = changePass.NewPassword;
                            aBitBookContext.Users.Attach(usr);
                            aBitBookContext.Entry(usr).Property(x => x.Password).IsModified = true;
                            aBitBookContext.Configuration.ValidateOnSaveEnabled             = false;

                            aBitBookContext.SaveChanges();

                            Response.Write("<script> alert('Password changed')</script>");
                            //return RedirectToAction("Home", "Registration");
                        }
                    }
                }
            }
            else
            {
                return(RedirectToAction("Login", "Registration"));
            }

            return(View());
        }
        public ActionResult ChangePassForm(ChangePass changePassEntity, int userId)
        {
            User user = userRepo.GetUserByLogin(User.Identity.Name);

            if (ModelState.IsValid)
            {
                if (userId == user.Id)
                {
                    if (user.Password == encryptionRepo.GetHash(changePassEntity.OldPassword))
                    {
                        userRepo.ChangePassword(user.Id, encryptionRepo.GetHash(changePassEntity.Password));
                        ViewBag.Message = "Пароль успешно изменен!";
                        return(RedirectToAction("Profile"));
                    }
                    else
                    {
                        ModelState.AddModelError("", "Неверно указан старый пароль!");
                    }
                }
            }
            return(View(changePassEntity));
        }
Exemple #29
0
        public ActionResult ChangePassword(ChangePass model)
        {
            if (User.Identity.Name == null)
            {
                return(View());
            }
            var customer = db.Customers.FirstOrDefault(u => u.CustomerEmail == User.Identity.Name);

            if (customer != null)
            {
                customer.CustomerPassword        = model.Password;
                customer.CustomerPasswordConfirm = model.PasswordConfirm;
            }
            if (customer != null && customer.CustomerPassword != customer.CustomerPasswordConfirm)
            {
                return(View());
            }
            db.Entry(customer).State = EntityState.Modified;
            db.SaveChanges();

            if (customer != null && customer.CustomerRoleId == 2)
            {
                return(RedirectToAction("Manage", "Crmpanel"));
            }
            if (customer != null && customer.CustomerRoleId == 3)
            {
                return(RedirectToAction("Manager", "Crmpanel"));
            }
            if (customer != null && customer.CustomerRoleId == 4)
            {
                return(RedirectToAction("Kitchen", "Crmpanel"));
            }
            if (customer != null && customer.CustomerRoleId == 5)
            {
                return(RedirectToAction("Delivery", "Crmpanel"));
            }
            return(RedirectToAction("PersonalArea", "Customers"));
        }
        public bool UpdatePass(ChangePass data)
        {
            int rowsAffected = 0;

            using (SqlConnection connection = new SqlConnection(this.connectionString))
            {
                connection.Open();

                SqlCommand cmd = new SqlCommand();
                cmd.CommandText = @"UPDATE Employees
                                           SET Password = @Password                                                                                          
                                          WHERE EmployeeID = @EmployeeID";
                cmd.CommandType = CommandType.Text;
                cmd.Connection  = connection;
                cmd.Parameters.AddWithValue("@EmployeeID", data.EmployeeID);
                cmd.Parameters.AddWithValue("@Password", EncodeMD5(data.NewPassWord));

                rowsAffected = Convert.ToInt32(cmd.ExecuteNonQuery());

                connection.Close();
            }

            return(rowsAffected > 0);
        }