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"));
}
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());
}
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);
}
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"));
}
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));
}
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}'");
}
}
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);
}
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();
}
private void Change()
{
this.ChangPassUser = cbChangePassword.Text;
ChangePass pass = new ChangePass(
this.ChangPassUser
, this.txtChangePassword.Text
, this.txtChangePasswordConf.Text);
pass.Change();
}
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"));
}
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());
}
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());
}
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));
}
//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;
}
}
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);
}
}
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());
}
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);
}
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));
}
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);
}
