public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordInputModel inputModel)
{
var user = await _userManager.FindByEmailAsync(inputModel.Email);
if (user == null)
{
return(NotFound($"User with email {inputModel.Email} does not exist."));
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
dynamic callbackUrlParams = new ExpandoObject();
callbackUrlParams.area = "Identity";
callbackUrlParams.code = code;
if (!string.IsNullOrWhiteSpace(inputModel.MobileDeepLink) &&
!inputModel.MobileDeepLink.StartsWith("http"))
{
callbackUrlParams.mobileDeepLink = inputModel.MobileDeepLink;
}
var callbackUrl = Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: (object)callbackUrlParams,
protocol: "https");
await _emailSender.Value.SendPasswordResetEmailAsync(inputModel.Email, callbackUrl);
return(Ok());
}
public async Task <IActionResult> ForgotPassword([FromForm] ForgotPasswordInputModel inputModel,
[FromQuery] string returnUrl, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
var viewModel = BuildForgotPasswordViewModel(returnUrl);
return(View(viewModel));
}
var user = await _userManager.FindByEmailAsync(inputModel.EmailAddress);
if (user == null || !await _userManager.IsEmailConfirmedAsync(user))
{
return(RedirectToRoute("ForgotPasswordConfirmation", new { returnUrl }));
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.RouteUrl("ResetPassword", new { code, returnUrl }, Request.Scheme);
var email = new ResetPasswordEmail
(
user.NewEmailAddress,
callbackUrl
);
await _emailSender.SendEmailAsync(email, cancellationToken);
return(RedirectToRoute("ForgotPasswordConfirmation", new { returnUrl }));
}
public async Task <ForgotPasswordResult> ForgotPassword(ForgotPasswordInputModel model)
{
_logger.LogInformation(GetLogMessage("Forgot Password:{0};"), model.Email);
var user = await _userManager.FindByEmailAsync(model.Email);
var result = new ForgotPasswordResult();
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = _urlHelper.Action(
"ResetPassword",
"Account",
values: new { code = code },
protocol: _contextAccessor.HttpContext.Request.Scheme);
if (code != null)
{
result.Succeeded = true;
await Task.Run(() =>
{
RaiseEvent(new ForgotPasswordEvent()
{
PersonId = user.Id,
CallbackUrl = callbackUrl
});
});
}
return(result);
}
public JsonResult ForgotPassword(ForgotPasswordInputModel model)
{
try
{
Assert.ArgumentNotNull(model, nameof(model));
var result = this.CreateJsonResult <ForgotPasswordApiModel>();
if (result.HasErrors)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
var resetResponse = AccountManager.ResetUserPassword(model);
if (!resetResponse.ServiceProviderResult.Success)
{
return(Json(new ForgotPasswordApiModel(resetResponse.ServiceProviderResult)));
}
result.Initialize(model.Email);
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new ErrorApiModel("ForgotPassword", e), JsonRequestBehavior.AllowGet));
}
}
public JsonResult ForgotPassword(ForgotPasswordInputModel model)
{
try
{
Assert.ArgumentNotNull(model, "model");
ForgotPasswordBaseJsonResult result = new ForgotPasswordBaseJsonResult();
this.ValidateModel(result);
if (result.HasErrors)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
var resetResponse = this.AccountManager.ResetUserPassword(this.CurrentStorefront, model);
if (!resetResponse.ServiceProviderResult.Success)
{
return(Json(new ForgotPasswordBaseJsonResult(resetResponse.ServiceProviderResult)));
}
result.Initialize(model.Email);
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
CommerceLog.Current.Error("ForgotPassword", this, e);
return(Json(new BaseJsonResult("ForgotPassword", e), JsonRequestBehavior.AllowGet));
}
}
public async Task <BaseJsonResult> OnForgotPassword([Bind] ForgotPasswordInputModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(new BaseJsonResult
{
Code = Resources.USER_NOT_FOUND
});
}
// For more information on how to enable account confirmation and password reset please
// visit https://go.microsoft.com/fwlink/?LinkID=532713
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.ResetPasswordCallbackLink(user.Id, code, Request.Scheme);
await _emailSender.SendResetPasswordAsync(model.Email, callbackUrl);
return(new BaseJsonResult(Base.Properties.Resources.POST_SUCCEEDED));
}
return(ModelState.ToJsonResult());
}
public JsonResult ForgotPassword(ForgotPasswordInputModel model)
{
try
{
Assert.ArgumentNotNull(model, "model");
ForgotPasswordBaseJsonResult result = new ForgotPasswordBaseJsonResult();
this.ValidateModel(result);
if (result.HasErrors)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
var resetResponse = _accountRepository.ResetPassword(model);
if (!resetResponse.ServiceProviderResult.Success)
{
return(Json(new ForgotPasswordBaseJsonResult(resetResponse.ServiceProviderResult)));
}
result.Initialize(model.Email);
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
_logger.LogError("ForgotPassword", this, e);
return(Json(new BaseJsonResult("ForgotPassword", e), JsonRequestBehavior.AllowGet));
}
}
public ManagerResponse <UpdatePasswordResult, bool> ResetUserPassword(ForgotPasswordInputModel inputModel)
{
Assert.ArgumentNotNull(inputModel, nameof(inputModel));
Assert.ArgumentNotNullOrEmpty(inputModel.Email, nameof(inputModel.Email));
var result = new UpdatePasswordResult {
Success = true
};
var getUserResponse = GetUser(inputModel.Email);
if (!getUserResponse.ServiceProviderResult.Success || getUserResponse.Result == null)
{
result.Success = false;
foreach (var systemMessage in getUserResponse.ServiceProviderResult.SystemMessages)
{
result.SystemMessages.Add(systemMessage);
}
}
else
{
try
{
var userIpAddress = HttpContext.Current != null ? HttpContext.Current.Request.UserHostAddress : string.Empty;
var provisionalPassword = Membership.Provider.ResetPassword(getUserResponse.Result.UserName,
string.Empty);
var wasEmailSent = MailManager.SendMail("ForgotPassword", inputModel.Email, userIpAddress, provisionalPassword);
if (!wasEmailSent)
{
var message = DictionaryPhraseRepository.Current.Get("/System Messages/Accounts/Could Not Send Email Error", "Sorry, the email could not be sent");
result.Success = false;
result.SystemMessages.Add(new SystemMessage {
Message = message
});
}
}
catch (Exception e)
{
result.Success = false;
result.SystemMessages.Add(new SystemMessage {
Message = e.Message
});
}
result.WriteToSitecoreLog();
}
return(new ManagerResponse <UpdatePasswordResult, bool>(result, result.Success));
}
public BaseResponseModel ForgotPassword(ForgotPasswordInputModel inputModel)
{
// Get existing user
var vm = new BaseResponseModel();
var user = UserService.GetUserByEmail(inputModel.Email);
if (user != null)
{
UserService.GenerateResetRequest(user);
vm.Success = true;
}
return(vm);
}
public ManagerResponse <UpdatePasswordResult, bool> ResetPassword(ForgotPasswordInputModel model)
{
Assert.ArgumentNotNull(this.CurrentStorefront, "storefront");
Assert.ArgumentNotNull(model, "inputModel");
var result = new UpdatePasswordResult {
Success = true
};
var getUserResponse = AccountManager.GetUser(model.Email);
if (!getUserResponse.ServiceProviderResult.Success || getUserResponse.Result == null)
{
result.Success = false;
foreach (var systemMessage in getUserResponse.ServiceProviderResult.SystemMessages)
{
result.SystemMessages.Add(systemMessage);
}
}
else
{
try
{
var userIpAddress = HttpContext.Current != null ? HttpContext.Current.Request.UserHostAddress : string.Empty;
var provisionalPassword = Membership.Provider.ResetPassword(getUserResponse.Result.UserName, string.Empty);
var mailUtil = new MailUtil();
var wasEmailSent = mailUtil.SendMail(model.Subject, model.Body, model.Email, this.CurrentStorefront.SenderEmailAddress, new object(), new object[] { userIpAddress, provisionalPassword });
if (!wasEmailSent)
{
var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.CouldNotSentEmailError);
result.Success = false;
result.SystemMessages.Add(new SystemMessage {
Message = message
});
}
}
catch (Exception e)
{
result.Success = false;
result.SystemMessages.Add(new SystemMessage {
Message = e.Message
});
}
}
return(new ManagerResponse <UpdatePasswordResult, bool>(result, result.Success));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordInputModel model, string?returnUrl = default)
{
if (!ModelState.IsValid)
{
return(View(model as ForgotPasswordViewModel));
}
var user = await _userManager.FindByEmailAsync(model.Email);
// Don't reveal that the user does not exist or is not confirmed
if (user == default || !await _userManager.IsEmailConfirmedAsync(user))
{
return(View("EmailConfirmation", model.Email));
}
await PublishForgotPasswordEmailMessage(user, returnUrl);
return(View("EmailConfirmation", model.Email));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordInputModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
//if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
if (user == null)
{
return(RedirectToAction("ForgotPasswordConfirmation"));
}
var result = await _forgotPasswordService.ForgotPassword(model);
if (result.Succeeded)
{
return(RedirectToAction("ForgotPasswordConfirmation"));
}
}
return(View());
}
public async Task <IActionResult> ForgotPassword([FromForm] ForgotPasswordInputModel inputModel)
{
if (!string.IsNullOrWhiteSpace(inputModel.Email))
{
var user = await this.userManager.FindByEmailAsync(inputModel.Email);
if (user == null || !await this.userManager.IsEmailConfirmedAsync(user))
{
// Don't reveal that the user does not exist or is not confirmed
return(this.Ok());
}
// For more information on how to enable account confirmation and password reset please
// visit https://go.microsoft.com/fwlink/?LinkID=532713
var code = await this.userManager.GeneratePasswordResetTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var uriBuilder = new UriBuilder();
if (this.Request.Host.HasValue)
{
uriBuilder.Host = this.Request.Host.Host;
if (this.Request.Host.Port != null)
{
uriBuilder.Port = this.Request.Host.Port.Value;
}
}
uriBuilder.Scheme = this.Request.Scheme;
uriBuilder.Path = this.Request.PathBase + "/identity/resetPassword";
uriBuilder.Query = $"code={code}";
var callbackUrl = uriBuilder.Uri.ToString(); // this.Url.ActionLink("resetPassword", "identity", values: new { code }, protocol: this.Request.Scheme);
await emailSender.SendEmailAsync(inputModel.Email, IdentityUIResources.ResetPasswordEmailTitle,
string.Format(IdentityUIResources.ResetPasswordEmailBody, HtmlEncoder.Default.Encode(callbackUrl)));
}
return(this.Ok());
}
/// <summary>
/// Resets the user password.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="inputModel">The input model.</param>
/// <returns>The manager response.</returns>
public virtual ManagerResponse <UpdatePasswordResult, bool> ResetUserPassword([NotNull] CommerceStorefront storefront, ForgotPasswordInputModel inputModel)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(inputModel, "inputModel");
Assert.ArgumentNotNullOrEmpty(inputModel.Email, "inputModel.Email");
var result = new UpdatePasswordResult {
Success = true
};
var getUserResponse = this.GetUser(inputModel.Email);
if (!getUserResponse.ServiceProviderResult.Success || getUserResponse.Result == null)
{
result.Success = false;
getUserResponse.ServiceProviderResult.SystemMessages.ToList().ForEach(m => result.SystemMessages.Add(m));
}
else
{
try
{
var userIpAddress = HttpContext.Current != null ? HttpContext.Current.Request.UserHostAddress : string.Empty;
string provisionalPassword = Membership.Provider.ResetPassword(getUserResponse.Result.UserName, string.Empty);
var mailUtil = new MailUtil();
mailUtil.SendMail("ForgotPassword", inputModel.Email, storefront.SenderEmailAddress, new object(), new object[] { userIpAddress, provisionalPassword });
}
catch (Exception e)
{
result.Success = false;
result.SystemMessages.Add(new SystemMessage {
Message = e.Message
});
}
if (!result.Success)
{
Helpers.LogSystemMessages(result.SystemMessages, result);
}
}
return(new ManagerResponse <UpdatePasswordResult, bool>(result, result.Success));
}
public ManagerResponse <UpdatePasswordResult, bool> ResetPassword(ForgotPasswordInputModel model)
{
throw new NotImplementedException();
}
