public async Task <IHttpActionResult> RequestPasswordReset(RequestPasswordResetViewModel model)
{
// Validates the received email address based on the view model
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Gets the user entity for the specified email address
var user = await _repo.FindByEmailAsync(model.Email);
if (user != null)
{
// Generates a password reset token for the user
string code = await _repo.GeneratePasswordResetTokenAsync(user.Id);
code = HttpUtility.UrlEncode(code);
Emailmodel emailmodel = new Emailmodel()
{
From = ConfigurationManager.AppSettings["Sender"], To = model.Email, Subject = Constants.Contants.ChangePassWordSubject, Body = ""
};
EmailSender emailSender = new EmailSender();
var callBackUrl = string.Format("https://{0}/doi-mat-khau?token={1}&email={2}", Request.RequestUri.Authority, code, model.Email);
emailmodel.Body = EmailSender.GetContentResetPassword(HostingEnvironment.MapPath(Constants.Contants.AccountRecoveryTemplateUrl), callBackUrl);
await emailSender.Execute(emailmodel.From, emailmodel.To, emailmodel.Subject, "", emailmodel.Body);
return(Ok());
}
// Displays a view asking the visitor to check their email and click the password reset link
return(BadRequest());
}
public async Task <IActionResult> SendPasswordResetLink(RequestPasswordResetViewModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var user = await UserManagerAgent.FindByNameAsync(model.UserName).ConfigureAwait(false);
if (user == null || !await UserManagerAgent.IsEmailConfirmedAsync(user).ConfigureAwait(false))
{
ViewBag.Message = "Error while resetting your password!";
return(View("Error"));
}
var token = await UserManagerAgent.GeneratePasswordResetTokenAsync(user).ConfigureAwait(false);
var resetLink = Url.Action("ResetPassword", "Account", new { token }, protocol: HttpContext.Request.Scheme);
// code to email the above link
string[] emailAddresses = { _appSettings.SMTP.AdminEmail, user.Email };
await _emailAgent.SendEmailAsync(_appSettings.SMTP.FromEmail, _appSettings.SMTP.FromEmail, emailAddresses,
"Winemakers Software - Password Reset.", CreatePasswordResetEmail(resetLink), true, null).ConfigureAwait(false);
// redirect to limbo page
return(RedirectToAction("PasswordLimbo", "Account"));
}
public async Task <ActionResult> RequestPasswordReset(RequestPasswordResetViewModel model)
{
// Validates the received email address based on the view model
if (!ModelState.IsValid)
{
return(View(model));
}
// Gets the user entity for the specified email address
Kentico.Membership.User user = UserManager.FindByEmail(model.Email);
if (user != null)
{
// Generates a password reset token for the user
string token = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
// Prepares the URL of the password reset link (targets the "ResetPassword" action)
// Fill in the name of your controller
string resetUrl = Url.Action("ResetPassword", "PasswordReset", new { userId = user.Id, token }, Request.Url.Scheme);
// Creates and sends the password reset email to the user's address
await UserManager.SendEmailAsync(user.Id, "Password reset request",
String.Format("To reset your account's password, click <a href=\"{0}\">here</a>", resetUrl));
}
// Displays a view asking the visitor to check their email and click the password reset link
return(View("CheckYourEmail"));
}
public IActionResult Get(string clientId)
{
SetViewBagClientId(new Guid(clientId));
var vm = new RequestPasswordResetViewModel()
{
ClientId = Guid.Parse(clientId)
};
return(View("RequestPasswordReset", vm));
}
public async Task <ActionResult> RequestPasswordReset(RequestPasswordResetViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var cmd = new RequestPasswordReset(model.EmailAddress);
await _messageBus.SendAsync(this.ClaimsUser(), cmd);
return(View("PasswordRequestReceived"));
}
public async Task <ActionResult> RequestPasswordReset(RequestPasswordResetViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var cmd = new RequestPasswordReset(model.EmailAddress);
await _commandBus.ExecuteAsync(cmd);
return(View("PasswordRequestReceived"));
}
public async Task <IActionResult> Post(Guid clientId, RequestPasswordResetViewModel requestPasswordResetViewModel)
{
SetViewBagClientId(clientId);
if (!ModelState.IsValid)
{
return(View("RequestPasswordReset", requestPasswordResetViewModel));
}
await Mediator.Send(new RequestPasswordResetRequest { ClientId = clientId, Email = requestPasswordResetViewModel.Email });
return(RedirectToAction("CodeSent", new { clientId, email = requestPasswordResetViewModel.Email }));
}
public void Setup()
{
_mediator = new Mock <IMediator>();
_owinWrapper = new Mock <IOwinWrapper>();
_logger = new Mock <ILogger>();
_accountOrchestrator = new AccountOrchestrator(_mediator.Object, _owinWrapper.Object, _logger.Object);
_requestPasswordResetViewModel = new RequestPasswordResetViewModel
{
Email = "*****@*****.**"
};
}
public ActionResult RequestPasswordReset(RequestPasswordResetViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(RedirectToCurrentUmbracoPage());
}
IPublishedContent homePage = HomePage;
string url = homePage.GetPropertyValue <IPublishedContent>("resetPasswordPage").Url;
_memberService.CreatePasswordRequest(SiteSettings, viewModel.Email, $"{url}?token={{token}}", Umbraco);
AddFeedback("An email containing password reset instructions has been sent", true);
return(RedirectToCurrentUmbracoPage());
}
public ActionResult RequestPasswordReset(RequestPasswordResetViewModel model)
{
var response = _userService.RequestPasswordReset(
new RequestPasswordResetRequest(model.EmailAddress));
if (response.Code != ResponseCode.Success && response.Code != ResponseCode.NotFound)
{
//this.AddErrorMessage("There has been an error requesting a password reset.");
}
else
{
//this.AddSuccessMessage("If entered email address exists you will receive a Password Reset email shortly.");
}
return(RedirectToAction("requestpasswordreset", "login"));
}
public async Task <RequestPasswordResetViewModel> StartForgottenPassword(string clientId, string returnUrl)
{
var model = new RequestPasswordResetViewModel();
var relyingParty = await _mediator.SendAsync(new GetRelyingPartyQuery { Id = clientId });
if (relyingParty == null)
{
AddInvalidClientIdReturnUrlMessage(model);
}
else
{
model.ReturnUrl = !string.IsNullOrEmpty(returnUrl) ? returnUrl : relyingParty.ApplicationUrl;
}
return(model);
}
public async Task <ActionResult> ForgottenCredentials(RequestPasswordResetViewModel requestPasswordResetViewModel, string clientId)
{
requestPasswordResetViewModel.ClientId = clientId;
requestPasswordResetViewModel = await _accountOrchestrator.RequestPasswordResetCode(requestPasswordResetViewModel);
var unlockCodeLength = await GetUnlockCodeLength();
if (string.IsNullOrEmpty(requestPasswordResetViewModel.Email) || !requestPasswordResetViewModel.Valid)
{
return(View("ForgottenCredentials", requestPasswordResetViewModel));
}
return(View("ResetPassword", new OrchestratorResponse <PasswordResetViewModel> {
Data = new PasswordResetViewModel {
Email = requestPasswordResetViewModel.Email, UnlockCodeLength = unlockCodeLength
}
}));
}
RequestPasswordReset(
RequestPasswordResetViewModel model,
ModelMethodContext context)
{
if (!context.ModelState.IsValid)
{
return;
}
// Validate the user password
var user = _userManager.FindByEmail(model.Email);
if ((user == null) || (!_userManager.IsEmailConfirmed(user.Id)))
{
context.ModelState.AddModelError(
"",
"The user either does not exist or is not confirmed.");
return;
}
// For more information on how to enable account confirmation and
// password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send email with the code and the redirect to reset password page
var code = _userManager.GeneratePasswordResetToken(user.Id);
var callbackUrl = GetResetPasswordRedirectUrl(code);
_userManager.SendEmail(
user.Id,
"Reset Password",
EmailService.CreatePasswordResetMessage(callbackUrl)
);
// Modify this code to remove the code reference for production.
// The code value should only be included for demonstration
// purposes!
StateController.Navigate(
"RequestPasswordResetConfirmation",
new NavigationData
{
{ CodeKey, code }
});
}
public async Task ThenTheResetCodeIsSent()
{
var response = new RequestPasswordResetViewModel
{
Email = _requestPasswordResetViewModel.Email,
ResetCodeSent = true
};
_accountOrchestrator.Setup(x => x.RequestPasswordResetCode(It.Is <RequestPasswordResetViewModel>(m => m.Email == _requestPasswordResetViewModel.Email)))
.ReturnsAsync(response);
var actual = await _accountController.ForgottenCredentials(_requestPasswordResetViewModel, "");
var viewResult = (ViewResult)actual;
var viewModel = (OrchestratorResponse <PasswordResetViewModel>)viewResult.Model;
Assert.IsNotNull(viewModel);
Assert.AreEqual(response.Email, viewModel.Data.Email);
Assert.AreEqual("ResetPassword", viewResult.ViewName);
}
public async Task <IActionResult> RequestPasswordReset(RequestPasswordResetViewModel vm)
{
bool res = await _accountService.CheckUserPasswordReset(vm.Username);
if (res)
{
var code = await _accountService.InitiatePasswordReset(vm.Username);
_mailServerService.ConfigureMailServer(new NetworkCredential("*****@*****.**", "Lizio123"), 587, "smtp.gmail.com", "*****@*****.**");
_mailServerService.SendMessage("Password Reset", "Hi,\n\t\tPlease use the following link to reset your password:\n" +
$"\t\t{HttpContext.Request.Scheme}://{HttpContext.Request.Host}{HttpContext.Request.PathBase}/Account/Reset/{code}", vm.Username);
}
var emailSentViewModel = new EmailSentViewModel
{
EmailAddress = vm.Username,
Message = "An email has been sent, you can find a link to reset your password their."
};
return(View("EmailSent", emailSentViewModel));
}
public async Task <IActionResult> RequestPasswordReset([FromBody] RequestPasswordResetViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
model.Email = model.Email.Trim();
try
{
var address = new MailAddress(model.Email);
}
catch (Exception e)
{
return(BadRequest("Podany adres E-Mail jest nieprawidłowy."));
}
var user = _context.Users.FirstOrDefault(u => u.Email.ToLower() == model.Email.ToLower());
if (user == null)
{
return(Ok());
}
var resetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
var resetLink = $"{Request.Scheme}://{Request.Host}/api/General/ResetPassword?email={WebUtility.UrlEncode(user.Email)}&token={WebUtility.UrlEncode(resetToken)}";
try
{
_emailService.SendEmail(user, "Resetowanie hasła", $"Odwiedź następujący link by zresetować hasło: {resetLink}");
}
catch (Exception e)
{
return(BadRequest("Spróbuj ponownie za chwilę lub skontaktuj się z administratorem."));
}
return(Ok());
}
public void Setup()
{
_logger = new Mock <ILogger>();
_requestPasswordResetViewModel = new RequestPasswordResetViewModel
{
Email = "*****@*****.**"
};
_accountOrchestrator = new Mock <AccountOrchestrator>();
_errorResponse = new RequestPasswordResetViewModel
{
Email = _requestPasswordResetViewModel.Email,
ResetCodeSent = false,
ErrorDictionary = new Dictionary <string, string>
{
{ "Email", "Error" }
}
};
_accountOrchestrator.Setup(x => x.RequestPasswordResetCode(It.Is <RequestPasswordResetViewModel>(m => m.Email == _requestPasswordResetViewModel.Email))).ReturnsAsync(_errorResponse);
_owinWrapper = new Mock <IOwinWrapper>();
_configurationService = new Mock <IConfigurationService>();
_accountController = new AccountController(_accountOrchestrator.Object, _owinWrapper.Object, new IdentityServerConfiguration(), _logger.Object);
}
public IActionResult LoadRequestResetPassword()
{
var vm = new RequestPasswordResetViewModel();
return(View("RequestPasswordReset", vm));
}
public virtual async Task <RequestPasswordResetViewModel> RequestPasswordResetCode(RequestPasswordResetViewModel model)
{
try
{
await _mediator.SendAsync(new RequestPasswordResetCodeCommand
{
Email = model.Email,
ReturnUrl = model.ReturnUrl
});
model.ResetCodeSent = true;
}
catch (InvalidRequestException ex)
{
_logger.Info(ex, ex.Message);
model.ErrorDictionary = ex.ErrorMessages;
}
return(model);
}
