Verify Code For Forgot Password in Asp.net Core

use this

var user = await userManager.FindByEmailAsync(model.Email);
var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);

complete code for reset password and forgot password is as follow

[HttpGet]
[AllowAnonymous]
public IActionResult ForgotPassword()
{
return View();
}
[HttpPost]
[AllowAnonymous]
public async Task ForgotPassword(ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
// Find the user by email
var user = await userManager.FindByEmailAsync(model.Email);
// If the user is found AND Email is confirmed
if (user != null && await userManager.IsEmailConfirmedAsync(user))
{
// Generate the reset password token
var token = await userManager.GeneratePasswordResetTokenAsync(user);
// Build the password reset link
var passwordResetLink = Url.Action("ResetPassword", "Account",
new { email = model.Email, token = token }, Request.Scheme);
// Log the password reset link
// Send the user to Forgot Password Confirmation view
return View("ForgotPasswordConfirmation");
}
// To avoid account enumeration and brute force attacks, don't
// reveal that the user does not exist or is not confirmed
return View("ForgotPasswordConfirmation");
}
return View(model);
}
[HttpGet]
[AllowAnonymous]
public IActionResult ResetPassword(string token, string email)
{
// If password reset token or email is null, most likely the
// user tried to tamper the password reset link
if (token == null || email == null)
{
ModelState.AddModelError("", "Invalid password reset token");
}
return View();
}
[HttpPost]
[AllowAnonymous]
public async Task ResetPassword(ResetPasswordViewModel model)
{
if (ModelState.IsValid)
{
// Find the user by email
var user = await userManager.FindByEmailAsync(model.Email);
if (user != null)
{
// reset the user password
var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
// Upon successful password reset and if the account is lockedout, set
// the account lockout end date to current UTC date time, so the user
// can login with the new password
if (await userManager.IsLockedOutAsync(user))
{
await userManager.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow);
}
return View("ResetPasswordConfirmation");
}
// Display validation errors. For example, password reset token already
// used to change the password or password complexity rules not met
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return View(model);
}
// To avoid account enumeration and brute force attacks, don't
// reveal that the user does not exist
return View("ResetPasswordConfirmation");
}
// Display validation errors if model state is not valid
return View(model);
}
[HttpGet]
public async Task ChangePassword()
{
var user = await userManager.GetUserAsync(User);
var userHasPassword = await userManager.HasPasswordAsync(user);
if (!userHasPassword)
{
return RedirectToAction("AddPassword");
}
return View();
}
[HttpPost]
public async Task ChangePassword(ChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await userManager.GetUserAsync(User);
if (user == null)
{
return RedirectToAction("Login");
}
// ChangePasswordAsync changes the user password
var result = await userManager.ChangePasswordAsync(user,
model.CurrentPassword, model.NewPassword);
// The new password did not meet the complexity rules or
// the current password is incorrect. Add these errors to
// the ModelState and rerender ChangePassword view
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return View();
}
// Upon successfully changing the password refresh sign-in cookie
await signInManager.RefreshSignInAsync(user);
return View("ChangePasswordConfirmation");
}
return View(model);
}
[HttpGet]
public async Task AddPassword()
{
var user = await userManager.GetUserAsync(User);
var userHasPassword = await userManager.HasPasswordAsync(user);
if (userHasPassword)
{
return RedirectToAction("ChangePassword");
}
return View();
}
[HttpPost]
public async Task AddPassword(AddPasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await userManager.GetUserAsync(User);
var result = await userManager.AddPasswordAsync(user, model.NewPassword);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return View();
}
await signInManager.RefreshSignInAsync(user);
return View("AddPasswordConfirmation");
}
return View(model);
}
}

1 Reply

Know the answer? Post it — somebody with the same question will find it here.

Sachin Singh5y ago
Accepted answer
use this
var user = await userManager.FindByEmailAsync(model.Email);
var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);
complete code for reset password and forgot password is as follow
[HttpGet]
       [AllowAnonymous]
       public IActionResult ForgotPassword()
       {
           return View();
       }


       [HttpPost]
       [AllowAnonymous]
       public async Task ForgotPassword(ForgotPasswordViewModel model)
       {
           if (ModelState.IsValid)
           {
               // Find the user by email
               var user = await userManager.FindByEmailAsync(model.Email);
               // If the user is found AND Email is confirmed
               if (user != null && await userManager.IsEmailConfirmedAsync(user))
               {
                   // Generate the reset password token
                   var token = await userManager.GeneratePasswordResetTokenAsync(user);

                   // Build the password reset link
                   var passwordResetLink = Url.Action("ResetPassword", "Account",
                           new { email = model.Email, token = token }, Request.Scheme);

                   // Log the password reset link


                   // Send the user to Forgot Password Confirmation view
                   return View("ForgotPasswordConfirmation");
               }

               // To avoid account enumeration and brute force attacks, don't
               // reveal that the user does not exist or is not confirmed
               return View("ForgotPasswordConfirmation");
           }

           return View(model);
       }


       [HttpGet]
       [AllowAnonymous]
       public IActionResult ResetPassword(string token, string email)
       {
           // If password reset token or email is null, most likely the
           // user tried to tamper the password reset link
           if (token == null || email == null)
           {
               ModelState.AddModelError("", "Invalid password reset token");
           }
           return View();
       }

       [HttpPost]
       [AllowAnonymous]
       public async Task ResetPassword(ResetPasswordViewModel model)
       {
           if (ModelState.IsValid)
           {
               // Find the user by email
               var user = await userManager.FindByEmailAsync(model.Email);

               if (user != null)
               {
                   // reset the user password
                   var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);
                   if (result.Succeeded)
                   {
                       // Upon successful password reset and if the account is lockedout, set
                       // the account lockout end date to current UTC date time, so the user
                       // can login with the new password
                       if (await userManager.IsLockedOutAsync(user))
                       {
                           await userManager.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow);
                       }
                       return View("ResetPasswordConfirmation");
                   }
                   // Display validation errors. For example, password reset token already
                   // used to change the password or password complexity rules not met
                   foreach (var error in result.Errors)
                   {
                       ModelState.AddModelError("", error.Description);
                   }
                   return View(model);
               }

               // To avoid account enumeration and brute force attacks, don't
               // reveal that the user does not exist
               return View("ResetPasswordConfirmation");
           }
           // Display validation errors if model state is not valid
           return View(model);
       }

       [HttpGet]
       public async Task ChangePassword()
       {
           var user = await userManager.GetUserAsync(User);

           var userHasPassword = await userManager.HasPasswordAsync(user);

           if (!userHasPassword)
           {
               return RedirectToAction("AddPassword");
           }

           return View();
       }
       [HttpPost]
       public async Task ChangePassword(ChangePasswordViewModel model)
       {
           if (ModelState.IsValid)
           {
               var user = await userManager.GetUserAsync(User);
               if (user == null)
               {
                   return RedirectToAction("Login");
               }

               // ChangePasswordAsync changes the user password
               var result = await userManager.ChangePasswordAsync(user,
                   model.CurrentPassword, model.NewPassword);

               // The new password did not meet the complexity rules or
               // the current password is incorrect. Add these errors to
               // the ModelState and rerender ChangePassword view
               if (!result.Succeeded)
               {
                   foreach (var error in result.Errors)
                   {
                       ModelState.AddModelError(string.Empty, error.Description);
                   }
                   return View();
               }

               // Upon successfully changing the password refresh sign-in cookie
               await signInManager.RefreshSignInAsync(user);
               return View("ChangePasswordConfirmation");
           }

           return View(model);
       }
       [HttpGet]
       public async Task AddPassword()
       {
           var user = await userManager.GetUserAsync(User);

           var userHasPassword = await userManager.HasPasswordAsync(user);

           if (userHasPassword)
           {
               return RedirectToAction("ChangePassword");
           }

           return View();
       }

       [HttpPost]
       public async Task AddPassword(AddPasswordViewModel model)
       {
           if (ModelState.IsValid)
           {
               var user = await userManager.GetUserAsync(User);

               var result = await userManager.AddPasswordAsync(user, model.NewPassword);

               if (!result.Succeeded)
               {
                   foreach (var error in result.Errors)
                   {
                       ModelState.AddModelError(string.Empty, error.Description);
                   }
                   return View();
               }

               await signInManager.RefreshSignInAsync(user);

               return View("AddPasswordConfirmation");
           }

           return View(model);
       }
   }
+2