public async Task <IActionResult> ChangePassword(string id, AdminChangePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await this.userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var token = await this.userManager.GeneratePasswordResetTokenAsync(user);
var result = await this.userManager.ResetPasswordAsync(user, token, model.Password);
if (result.Succeeded)
{
TempData.AddSuccessMessage($"Password changed successfully for user {user.UserName}.");
return(RedirectToAction(nameof(Index)));
}
else
{
AddModelErrors(result);
return(View(model));
}
}
public ActionResult ChangePassword(AdminChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
if (User.Identity.IsAuthenticated && User.IsInRole("admin"))
{
using (var Context = new ProjectDBEntities())
{
var OldHashedPassword = Hashing.CreateHash(model.OldPassword);
var user = Context.Administrators.Where(ax => ax.AdminUserName == User.Identity.Name && ax.AdminPassword == OldHashedPassword).FirstOrDefault <Administrator>();
if (user != null)
{
user.AdminPassword = Hashing.CreateHash(model.NewPassword);
Context.SaveChanges();
ViewBag.Message = "Password Changed Successfully to " + model.NewPassword;
return(View(new AdminChangePasswordViewModel()));
}
else
{
ViewBag.Message = "Old password seems different";
return(View(new AdminChangePasswordViewModel()));
}
}
}
}
return(Content(User.Identity.Name));
}
public async Task <IActionResult> Shifrenideyish(AdminChangePasswordViewModel adminChangePasswordViewModel)
{
if (!ModelState.IsValid)
{
return(View(adminChangePasswordViewModel));
}
string activeUserName = User.Identity.Name;
CustomUser customUserFromDb = await _userManager.FindByNameAsync(activeUserName);
IdentityResult result = await _userManager.ChangePasswordAsync(customUserFromDb, adminChangePasswordViewModel.CurrentPassword, adminChangePasswordViewModel.NewPassword);
await _userManager.UpdateAsync(customUserFromDb);
if (!result.Succeeded)
{
ModelState.AddModelError("CurrentPassword", "Hazırki şifrə yanlışdır və ya yeni şifrə tələblərə uyğun deyil.");
ModelState.AddModelError("NewPassword", "Hazırki şifrə yanlışdır və ya yeni şifrə tələblərə uyğun deyil.");
return(View(adminChangePasswordViewModel));
}
TempData["PasswordChanged"] = true;
return(View());
}
public async Task <IActionResult> ChangePassword(AdminChangePasswordViewModel model)
{
try
{
var requestResult = await this.Mediator.Send(new ChangePasswordCommand
{
UserId = this.HttpContext.GetCurrentUserId().Value,
CurrentPassword = model.CurrentPassword,
NewPassword = model.NewPassword,
ConfirmedPassword = model.ConfirmedPassword,
});
if (requestResult.Succeeded)
{
this.ShowSuccessNotification("Password has been changed successfully.");
return(this.View());
}
else
{
this.ShowErrorNotification("Password has not been changed successfully.");
return(this.View(model));
}
}
catch (ValidationException ex)
{
this.ModelState.ApplyValidationException(ex, true);
}
catch (Exception)
{
this.ModelState.AddModelError(string.Empty, "Change password operation has failed.");
}
return(this.View(model));
}
public async Task <IHttpActionResult> ChangeAdminPassword([FromBody] AdminChangePasswordViewModel adminChangePassword)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_applicationUserManager.FindById(adminChangePassword.Id) == null)
{
return(NotFound());
}
var result = _applicationUserManager.ChangePassword(adminChangePassword.Id, adminChangePassword.OldPassword, adminChangePassword.NewPassword);
if (result.Succeeded)
{
var user = _context.Users.Where(x => x.Id.Equals(adminChangePassword.Id)).First();
_loggerService.Log(UserId, ActionType.Update, $"Admin password changed - {adminChangePassword.Id}");
await _emailService.Send(user.Email, "Password changed", $"Username: {user.UserName} Password: {adminChangePassword.NewPassword}");
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> ChangePassword(string id, AdminChangePasswordViewModel model, string redirectUrl)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(RedirectToAction("Index"));
}
var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
TempData["Notification"] = Notification.ShowNotif("خطایی رخ داد.", ToastType.Red);
return(PartialView("ChangePassword", model));
}
//await _signInManager.RefreshSignInAsync(user);
TempData["Notification"] = Notification.ShowNotif("رمز عبور شما با موفقیت ویرایش شد.", ToastType.Green);
return(PartialView("_SuccessfulResponse", redirectUrl));
}
return(PartialView("ChangePassword", model));
}
public ActionResult ChangePassword(AdminChangePasswordViewModel model)
{
if(ModelState.IsValid)
{
if(User.Identity.IsAuthenticated && User.IsInRole("admin"))
{
using(var Context = new ProjectDBEntities())
{
var OldHashedPassword = Hashing.CreateHash(model.OldPassword);
var user = Context.Administrators.Where(ax => ax.AdminUserName == User.Identity.Name && ax.AdminPassword == OldHashedPassword).FirstOrDefault<Administrator>();
if (user != null)
{
user.AdminPassword = Hashing.CreateHash(model.NewPassword);
Context.SaveChanges();
ViewBag.Message = "Password Changed Successfully to " + model.NewPassword;
return View(new AdminChangePasswordViewModel());
}
else
{
ViewBag.Message = "Old password seems different";
return View(new AdminChangePasswordViewModel());
}
}
}
}
return Content(User.Identity.Name);
}
public ActionResult ChangePassword(string id)
{
var user = _context.Users.FirstOrDefault(model => model.Id == id);
var changePasswordViewModel = new AdminChangePasswordViewModel()
{
UserId = user.Id
};
return(View(changePasswordViewModel));
}
public ActionResult AdminChangePassword()
{
var vendorId = User.Identity.GetUserId();
var vendor = db.Users.FirstOrDefault(m => m.Id == vendorId);
var model = new AdminChangePasswordViewModel {
Email = vendor.Email
};
return(View(model));
}
public ActionResult ChangeUserPassword(string id)
{
var user = _context.Users.SingleOrDefault(t => t.Id == id);
var adminChangePass = new AdminChangePasswordViewModel()
{
UserId = user.Id,
UserName = user.UserName,
};
return(View(adminChangePass));
}
public async Task <ActionResult> ChangeUserPassword(AdminChangePasswordViewModel model)
{
var user = _context.Users.Where(t => t.Id == model.UserId).First();
if (user.PasswordHash != null)
{
await _userManager.RemovePasswordAsync(user.Id);
}
await _userManager.AddPasswordAsync(user.Id, model.NewPassword);
return(RedirectToAction("UsersWithRoles", "ManageUsers"));
}
public async Task <ActionResult> ChangeUserPassword(AdminChangePasswordViewModel usermodel)
{
var userId = _userRepository.GetUserByUserName(usermodel.UserName).Id;
ApplicationUser user = await UserManager.FindByIdAsync(userId);
user.PasswordHash = UserManager.PasswordHasher.HashPassword(usermodel.NewPassword);
var result = await UserManager.UpdateAsync(user);
if (!result.Succeeded)
{
//throw exception......
}
return(View(usermodel));
}
public async Task <IActionResult> ChangePassword(string id)
{
var user = await this.userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var model = new AdminChangePasswordViewModel
{
Email = user.Email,
Username = user.UserName,
};
return(View(model));
}
public ActionResult ChangePassword(AdminChangePasswordViewModel model)
{
var user = _context.Users.SingleOrDefault(t => t.Id == model.UserId);
if (!ModelState.IsValid)
{
ModelState.AddModelError("Validation", "Some thing is wrong");
return(View(model));
}
if (user.PasswordHash != null)
{
_usermanager.RemovePassword(user.Id);
}
_usermanager.AddPassword(user.Id, model.NewPassword);
return(_usermanager.GetRoles(user.Id).First() == "trainer"?
RedirectToAction("TrainerView", "Admin"):
RedirectToAction("StaffView", "Admin"));
}
public async Task <IHttpActionResult> ChangePassword([FromBody] AdminChangePasswordViewModel adminResetPassword)
{
if (!ModelState.IsValid)
{
return(Content(HttpStatusCode.BadRequest, GetValidationErrors()));
}
var result = await _applicationUserManager.ChangePasswordAsync(UserId, adminResetPassword.OldPassword, adminResetPassword.NewPassword);
if (result.Succeeded)
{
_loggerService.Log(UserId, ActionType.Update, $"Admin password changed - {UserId}");
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> ChangePassword(AdminChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await this.userManager.GetUserAsync(User);
var changePasswordResult = await this.userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword);
if (!changePasswordResult.Succeeded)
{
AddErrors(changePasswordResult);
}
else
{
TempData["SuccessStatusMessage"] = "Password has been changed successfully.";
}
}
return(View(model));
}
public async Task <ActionResult> AdminChangePassword(AdminChangePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("AdminDetails", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
AddErrors(result);
return(View(model));
}
public async Task <ActionResult> ChangePassword(AdminChangePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userdata = _userService.Find(model.id);
if (userdata == null)
{
return(RedirectToAction("Manage"));
}
IdentityResult passwordChangeResult = await _userService.ResetPasswordAsync(userdata, model.NewPassword);
if (passwordChangeResult.Succeeded)
{
return(RedirectToAction("Manage"));
}
AddErrors(passwordChangeResult);
return(View(model));
}
public IActionResult ChangePassword()
{
AdminChangePasswordViewModel model = new AdminChangePasswordViewModel();
return(View(model));
}
