//
// GET: /Manage/ChangePassword
public ActionResult ChangePassword(int id)
{
AdminResetPasswordViewModel model = new AdminResetPasswordViewModel();
model.UserId = id;
return(View(model));
}
public async Task<ActionResult> ResetPassword(AdminResetPasswordViewModel model)
{
var user = await UserManager.FindByIdAsync(model.UserId);
if (user == null)
{
return HttpNotFound();
}
if (ModelState.IsValid)
{
try
{
var token = UserManager.GeneratePasswordResetToken(user.Id);
var result = await UserManager.ResetPasswordAsync(user.Id, token, model.NewPassword);
if (result == IdentityResult.Success)
{
SetSuccessMessage("Password was updated for {0} successfully!", user.UserName);
return RedirectToAction("Index");
}
else
{
throw new Exception(string.Join("\r\n", result.Errors));
}
}
catch (Exception e)
{
SetFailureMessage(e.Message);
}
}
model.UserName = user.UserName;
return View(model);
}
public async Task <ActionResult> AdminResetPassword(AdminResetPasswordViewModel item, String id)
{
if (!ModelState.IsValid)
{
return(View(item));
}
var user = await UserManager.FindByIdAsync(id);
var token = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction("ResetPasswordConfirmation", "AccountAdmin"));
}
var result = await UserManager.ResetPasswordAsync(user.Id, token, item.Password);
if (result.Succeeded)
{
return(RedirectToAction("ResetPasswordConfirmation", "AccountAdmin"));
}
AddErrors(result);
return(View());
}
public async Task <bool> AdminResetPasswordAsync(string url, AdminResetPasswordViewModel objToResetPassword, string token)
{
var request = new HttpRequestMessage(HttpMethod.Post, url);
if (objToResetPassword != null)
{
request.Content = new StringContent(
JsonConvert.SerializeObject(objToResetPassword), Encoding.UTF8, "application/json");
}
else
{
return(false);
}
var client = _clientFactory.CreateClient();
if (token != null && token.Length != 0)
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
}
HttpResponseMessage response = await client.SendAsync(request);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(true);
}
return(false);
}
public async Task <ActionResult> AdminResetPassword(int?id)
{
AdminResetPasswordViewModel obj = new AdminResetPasswordViewModel();
User user = await _accRepo.GetAsync(SD.AccountAPIPath, id.GetValueOrDefault(), HttpContext.Session.GetString("JWToken"));
obj.Username = user.Username;
return(View(obj));
}
public async Task <ActionResult> AdminResetPassword(AdminResetPasswordViewModel arpvm)
{
if (ModelState.IsValid)
{
await _accRepo.AdminResetPasswordAsync(SD.AccountAPIPath + "adminresetpassword/", arpvm, HttpContext.Session.GetString("JWToken"));
return(RedirectToAction(nameof(Upsert)));
}
return(View(arpvm));
}
public async Task <ActionResult> AdminResetPassword(string userName, string code)
{
AdminResetPasswordViewModel model = new AdminResetPasswordViewModel();
var user = await UserManager.FindByNameAsync(userName);
model.UserName = userName;
model.Code = code;
return(View(model));
}
public async Task <IActionResult> ResetPassword(AdminResetPasswordViewModel model)
{
if (this.User.Identity.IsAuthenticated)
{
return(this.AdminDashboardActionResult);
}
if (this.ModelState.IsValid)
{
var result = await this.identityService.ResetPasswordAsync(model.UserId, model.PasswordResetToken, model.NewPassword);
if (result)
{
this.TempData["SuccessStatusMessage"] = "You successfully changed your password!";
return(this.Redirect(nameof(this.Login)));
}
}
return(this.View(model));
}
public async Task <IHttpActionResult> ResetAdminPassword([FromBody] AdminResetPasswordViewModel adminResetPassword)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_applicationUserManager.FindById(adminResetPassword.Id) == null)
{
return(NotFound());
}
var user = _context.Users.Where(x => x.Id.Equals(adminResetPassword.Id)).First();
var password = System.Web.Security.Membership.GeneratePassword(adminResetPassword.Length, adminResetPassword.SpecialCharacters);
user.PasswordHash = _applicationUserManager.PasswordHasher.HashPassword(password);
_context.SaveChanges();
_loggerService.Log(UserId, ActionType.Update, $"Admin password reset - {adminResetPassword.Id}");
await _emailService.Send(user.Email, "Password changed", $"Username: {user.UserName} Password: {password}");
return(Ok());
}
public async Task <ActionResult> AdminResetPassword(AdminResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByNameAsync(model.UserName);
if (user == null)
{
TempData["SaveResult"] = $"Error resetting password for {model.UserName}. Please retry.";
return(RedirectToAction("Index", "Users"));
}
var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
if (result.Succeeded)
{
TempData["SaveResult"] = $"Password reset for {model.UserName} completed successfully.";
return(RedirectToAction("Index", "Users"));
}
AddErrors(result);
return(View(model));
}
public async Task <ActionResult> ChangePassword(AdminResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userId = model.UserId.Value;
string resetToken = await UserManager.GeneratePasswordResetTokenAsync(model.UserId.Value);
var result = await UserManager.ResetPasswordAsync(userId, resetToken, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(userId);
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
AddErrors(result);
return(View(model));
}
