public async Task <IActionResult> ResetPassword(ResetUserPasswordViewModel model)
{
var item = DataContext.Users
.Where(p => p.Id == model.Id)
.Select(p => p)
.FirstOrDefault();
model.EmailAddress = item.Email;
if (!ModelState.IsValid)
{
AddError("Error", ModelState, state => state.Children != null && state.Children.Any() /*checks for IValidatableObject (because those have children)*/);
return(View(model));
}
var token = await UserManager.GeneratePasswordResetTokenAsync(item);
var result = await UserManager.ResetPasswordAsync(item, token, model.Password);
if (result.Errors.Any())
{
AddError("Error", string.Join("\r\n", result.Errors.Select(e => e.Description)));
return(View(model));
}
DataContext.SaveChanges();
AddSuccess("Success", $"Reset user {model.EmailAddress} password successfully");
return(RedirectToAction("Index"));
}
public async Task <IActionResult> ResetUserPassword(ResetUserPasswordViewModel resetUserPasswordViewModel)
{
if (ModelState.IsValid)
{
var user = await _userManager.Users.FirstOrDefaultAsync(a => a.Id == resetUserPasswordViewModel.id);
if (user != null)
{
var removePasswordResult = await _userManager.RemovePasswordAsync(user);
if (removePasswordResult.Succeeded)
{
var addPasswordResult = await _userManager.AddPasswordAsync(user, resetUserPasswordViewModel.NewPassword);
if (addPasswordResult.Succeeded)
{
return(RedirectToAction(nameof(ListUsers), new { Message = ManageMessageId.SetPasswordSuccess }));
}
}
AddErrors(removePasswordResult);
return(View(resetUserPasswordViewModel));
}
return(RedirectToAction(nameof(ListUsers), new { Message = ManageMessageId.Error }));
}
return(View(resetUserPasswordViewModel));
}
public async Task <JsonResult> ResetUserPassword(ResetUserPasswordViewModel model)
{
var result = new { Success = true, Message = "Success" };
if (ModelState.IsValid)
{
try
{
var resetToken = await _userManager.GeneratePasswordResetTokenAsync(model.UserId);
var defaultPassword = _parameterService.GetParameterByNameAndCache <string>(ParameterNames.UserResetPassword);
var identityResult = await _userManager.ResetPasswordAsync(model.UserId, resetToken, defaultPassword);
if (!identityResult.Succeeded)
{
result = new { Success = false, Message = identityResult.Errors.First() };
_contextManager.ResponseManager.StatusCode = 500;
_contextManager.ResponseManager.AppendHeader(ModelStateErrorNames.ErrorMessage, result.Message);
}
}
catch (Exception ex)
{
_contextManager.ResponseManager.StatusCode = 500;
_contextManager.ResponseManager.AppendHeader(ModelStateErrorNames.ErrorMessage, ex.Message);
result = new { Success = false, ex.Message };
}
}
else
{
var errors = ModelState.GetModelStateMesssages();
result = new { Success = false, Message = errors.First() };
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> ResetUserPassword(ResetUserPasswordViewModel model)
{
ApplicationDbContext context = new ApplicationDbContext();
UserStore <ApplicationUser> store = new UserStore <ApplicationUser>(context);
UserManager <ApplicationUser> UserManager = new UserManager <ApplicationUser>(store);
String userId = model.UserId; // User.Identity.GetUserId();//"<YourLogicAssignsRequestedUserId>";
String newPassword = model.ConfirmPassword; // "test@123"; //"<PasswordAsTypedByUser>";
String hashedNewPassword = UserManager.PasswordHasher.HashPassword(newPassword);
ApplicationUser cUser = await store.FindByIdAsync(userId);
await store.SetPasswordHashAsync(cUser, hashedNewPassword);
await store.UpdateAsync(cUser);
var hased = MD5Hash(model.ConfirmPassword);
var person = db.AspNetUsers.FirstOrDefault(o => o.Id == userId);
if (person != null)
{
person.MD5Hash = hased;
db.Entry(person).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("UsersWithRoles", "Account", new { area = "", }));
//return View(model);
}
public async Task <ActionResult> ResetUserPassword(ResetUserPasswordViewModel model)
{
var validatePassword = await UserManager.PasswordValidator.ValidateAsync(model.NewPassword);
if (ModelState.IsValid && validatePassword.Succeeded)
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(_context));
var user = userManager.FindById(model.Id);
if (user == null)
{
return(View(model));
}
await userManager.RemovePasswordAsync(model.Id);
var result = await userManager.AddPasswordAsync(model.Id, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Edit", new { id = model.Id, Message = ManageMessageId.ResetUserPasswordSuccess }));
}
}
AddErrors(validatePassword);
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> ResetPassword(ResetUserPasswordViewModel model, string id)
{
var user = UserManager.FindById(id);
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await UserManager.ResetPasswordAsync(id, model.Code, model.Password);
if (result.Succeeded)
{
TempData["message"] = "Password for - " + user.UserName + " changed successfully";
TempData["messageType"] = "success";
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
TempData["message"] = "Error changing password for - " + user.UserName + " " + ex.GetBaseException().Message;
TempData["messageType"] = "danger";
}
return(View());
}
public ActionResult SetPassword(string id)
{
ResetUserPasswordViewModel model = new ResetUserPasswordViewModel()
{
UserName = GetApplicationUserById(id).UserName
};
return(View(model));
}
public ActionResult ResetPassword(string userName)
{
var model = new ResetUserPasswordViewModel()
{
Username = userName
};
return(View(model));
}
/// <summary>
/// Renders view with ResetUserPasswordViewModel to reset the password of the user
/// </summary>
/// <param name="id">User id of the user whose password is to be reseted</param>
/// <returns></returns>
public ActionResult ResetPassword(string id)
{
ResetUserPasswordViewModel model = new ResetUserPasswordViewModel();
model.Code = UserManager.GeneratePasswordResetToken(id);
ApplicationUser user = UserManager.FindById(id);
model.Email = user.Email;
return(View(model));
}
public void SetPassword(ResetUserPasswordViewModel model, ClaimsPrincipal ctx)
{
AuthenticablePrincipal principal = this.GetUser(model.Id);
authorizationLogic.IsAuthorizedThrowsException(AuthorizationScopes.ManageUsers, ctx, principal, EventCategory.UserManagementResetPassword);
principal.PasswordHash = BCrypt.Net.BCrypt.HashPassword(model.NewPassword);
configurationRepository.Update <AuthenticablePrincipal>(principal);
}
public ActionResult ResetPassword(ResetUserPasswordViewModel model)
{
var user = _session.Query <User>().FirstOrDefault(x => x.Username == model.Username);
if (model.NewPassword != model.ConfirmNewPassword)
{
ModelState.AddModelError("ConfirmNewPassword", "New password confirmation incorrect");
return(View("ResetPassword", model));
}
user.ChangePassword(Encryption.HashPassword(model.NewPassword));
return(RedirectToAction("Index", "Administration"));
}
public IActionResult Reset(string userId = null, string token = null)
{
if (token == null)
{
return(Redirect(Url.HomeLink()));
}
var model = new ResetUserPasswordViewModel
{
Token = token
};
return(View(model));
}
public async Task <IActionResult> ResetPassword(int id)
{
var item = DataContext.Users
.Where(p => p.Id == id)
.Select(p => p)
.FirstOrDefault();
var model = new ResetUserPasswordViewModel()
{
EmailAddress = item.Email,
Id = item.Id
};
return(View(model));
}
public async Task <ActionResult> SetPassword(ResetUserPasswordViewModel model)
{
var user = await UserManager.FindByNameAsync(model.UserName);
if (user == null)
{
ModelState.AddModelError("", "用户不存在。");
model.NewPassword = model.ConfirmPassword = "";
return(View(model));
}
string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
var result = await UserManager.ResetPasswordAsync(user.Id, code, model.NewPassword);
return(RedirectToAction("Index", new { id = user.Id, message = UsersAdministrationMessageId.ResetPasswordSuccess }));
}
// GET: /Admin/ResetUserPassword/Id
public ActionResult ResetUserPassword(string id)
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(_context));
var user = userManager.FindById(id);
if (user == null)
{
return(RedirectToAction("Edit", new { id = id }));
}
ResetUserPasswordViewModel reset = new ResetUserPasswordViewModel
{
Id = id
};
return(View(reset));
}
// GET: /UserAdmin/ResetPassword
public ActionResult ResetPassword(string id)
{
if (!IsLoggedIn())
{
return(RedirectToAction("login", "account"));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ViewBag.poscategories = db.PostCategory.Where(x => x.isactive == true).OrderBy(x => x.id).ToList();
ResetUserPasswordViewModel model = new ResetUserPasswordViewModel()
{
Id = id
};
return(View(model));
}
/// <inheritDoc/>
public async Task <string> CreateReportForResetUserPasswordAsync(string userId, string callbackUrl)
{
string name = "~/Areas/Report/Views/UserReport/ResetUserPassword.cshtml";
var user = await _identityUserManager.FindByIdAsync(userId);
if (user != null)
{
var model = new ResetUserPasswordViewModel()
{
UserId = userId, UserName = user.UserName, CallbackUrl = callbackUrl
};
return(await _viewHelper.RenderViewToStringAsync(name, model));
}
else
{
throw new Exception("User not found");
}
}
public async Task <ActionResult> ResetPassword(ResetUserPasswordViewModel model)
{
if (!IsLoggedIn())
{
return(RedirectToAction("login", "account"));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var removePassword = UserManager.RemovePassword(model.Id);
if (removePassword.Succeeded)
{
//Removed Password Success
var validPass = await UserManager.PasswordValidator.ValidateAsync(model.NewPassword);
if (validPass.Succeeded)
{
var AddPassword = UserManager.AddPassword(model.Id, model.NewPassword);
if (AddPassword.Succeeded)
{
return(View("PasswordResetConfirm"));
}
}
else
{
string errors = string.Empty;
foreach (var items in validPass.Errors)
{
errors += items.ToString();
}
ModelState.AddModelError("", errors);
return(View(model));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public ActionResult ResetUserPassword(ResetUserPasswordViewModel model)
{
if (ModelState.IsValid)
{
UserManager <IdentityUser> userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>());
if (userManager.HasPassword(model.UserId))
{
userManager.RemovePassword(model.UserId);
userManager.AddPassword(model.UserId, model.ConfirmPassword);
}
TempData["Message"] = "Password successfully reset to " + model.ConfirmPassword;
TempData["MessageValue"] = "1";
return(RedirectToAction("Index", "Korisnici"));
}
// If we got this far, something failed, redisplay form
TempData["Message"] = "Invalid User Details. Please try again in some minutes ";
TempData["MessageValue"] = "0";
return(RedirectToAction("Index", "Korisnici"));
}
public async Task <bool> ResetUserPassword([FromBody] ResetUserPasswordViewModel model)
{
if (ModelState.IsValid)
{
ApplicationUser dbUser = _userManager.Users.FirstOrDefault(u => u.Id == model.Id);
if (dbUser.Id == model.Id)
{
dbUser.PasswordHash = _userManager.PasswordHasher.HashPassword(dbUser, model.Password);
var result = await _userManager.UpdateAsync(dbUser);
return(result.Succeeded);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public async Task <IActionResult> Reset(ResetUserPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var user = await _identityService.GetUserByEmail(model.Email);
var resetUserPasswordResponse = await _mediator.Send(new ResetUserPasswordCommand()
{
Password = model.Password,
ConfirmPassword = model.ConfirmPassword,
Token = model.Token,
User = user
});
if (resetUserPasswordResponse.IdentityResult.Succeeded)
{
return(RedirectToAction(nameof(ResetConfirmation)));
}
if (resetUserPasswordResponse.IdentityResult.Errors.Count() > 0)
{
AddErrors(resetUserPasswordResponse.IdentityResult);
}
}
catch (ValidationException ex)
{
AddErrors(ex);
}
return(View(model));
}
public ActionResult ResetUserPassword(ResetUserPasswordViewModel model)
{
userManagement.SetPassword(model, User);
return(http.RespondSuccess());
}
