public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction("ResetPasswordConfirmation", "Profile"));
}
// remove the password
var PasswordRemove = await UserManager.RemovePasswordAsync(user.Id);
var PasswordUpdate = await UserManager.AddPasswordAsync(user.Id, model.Password);
if (PasswordUpdate.Succeeded)
{
return(RedirectToAction("ResetPasswordConfirmation", "Profile"));
}
AddErrors(PasswordUpdate);
return(View());
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
var addPasswordResult = await _userManager.AddPasswordAsync(user, Input.NewPassword);
if (!addPasswordResult.Succeeded)
{
foreach (var error in addPasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your password has been set.";
return(RedirectToPage());
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
UserManager.RemovePassword(model.UserID);
var result = await UserManager.AddPasswordAsync(model.UserID, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(model.UserID);
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
return(View(model));
}
public async Task <IActionResult> Users(string username, [FromBody] UserDto request)
{
_logger.LogInformation("Updating user {0} in tenant {1} by {2}", username, User.Tenant(), User.Identity?.Name);
var user = await _userManager.FindByNameAndTenantAsync(username, User.Tenant());
if (user == null)
{
return(NotFound());
}
if (!string.IsNullOrEmpty(request.Password))
{
await _userManager.RemovePasswordAsync(user);
await _userManager.AddPasswordAsync(user, request.Password);
}
if (request.IsLocked.HasValue)
{
user.LockoutEnd = request.IsLocked.Value ? DateTimeOffset.MaxValue : DateTimeOffset.MinValue;
}
if (request.IsAdmin.HasValue)
{
user.IsClinicAdmin = request.IsAdmin.Value;
}
await _userManager.UpdateAsync(user);
return(Ok());
}
public async Task <IHttpActionResult> SetPassword(int id, [FromBody] SetPasswordDto dto)
{
if ((await _userManager.FindByIdAsync(id)) == null)
{
return(NotFound());
}
await _userManager.RemovePasswordAsync(id);
await _userManager.AddPasswordAsync(id, dto.Password);
return(StatusCode(HttpStatusCode.Accepted));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), 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("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> ManagerChangePassword(ManagerChangePasswordViewModel model, string Id)
{
if (!ModelState.IsValid)
{
return(View(model));
}
UserManager.RemovePassword(Id);
var result = await UserManager.AddPasswordAsync(Id, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(Id);
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("EditEmployee", "RoleAdmin", new { Id = Id }));
}
AddErrors(result);
return(View(model));
}
public async Task <ActionResult> Edit(string id, string email, string password)
{
AppUser user = await _userManager.FindByIdAsync(id);
if (user != null)
{
user.Email = email;
IdentityResult validEmail = await _userValidator.ValidateAsync(_userManager, user);
if (!validEmail.Succeeded)
{
AddErrorsFromResult(validEmail);
}
IdentityResult validPass = null;
if (password != string.Empty)
{
validPass = await _passwordValidator.ValidateAsync(_userManager, user, password);
if (validPass.Succeeded)
{
await _userManager.RemovePasswordAsync(user);
await _userManager.AddPasswordAsync(user, password);
}
else
{
AddErrorsFromResult(validPass);
}
}
if ((validEmail.Succeeded && validPass == null) || (validEmail.Succeeded && password != string.Empty && validPass.Succeeded))
{
IdentityResult result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
AddErrorsFromResult(result);
}
}
else
{
ModelState.AddModelError("", "User Not Found");
}
return(View(user));
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess }));
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task HandleUpdateUserPassword(UpdateUserPasswordCommand command)
{
if (string.IsNullOrEmpty(command.CurrentPassword))
{
command.Result = await userManager.AddPasswordAsync(command.UserId, command.NewPassword);
}
else
{
command.Result = await userManager.ChangePasswordAsync(command.UserId, command.CurrentPassword, command.NewPassword);
}
if (!command.Result.Succeeded)
{
throw new IdentityException(command.Result);
}
}
public async Task <IHttpActionResult> SetPassword(SetPasswordBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result = await AppUserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), 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("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// Si llegamos a este punto, es que se ha producido un error, volvemos a mostrar el formulario
return(View(model));
}
