public async Task <ActionResult> HandleForgottenPassword(ForgottenPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("ForgottenPassword", model));
}
//Find the member with the email address
var findMember = Services.MemberService.GetByEmail(model.EmailAddress);
if (findMember != null)
{
//Set expiry date to
DateTime expiryTime = DateTime.Now.AddMinutes(15);
//Lets update resetGUID property
findMember.SetValue("resetGUID", expiryTime.ToString("ddMMyyyyHHmmssFFFF"));
Services.MemberService.Save(findMember);
//Send user an email to reset password with GUID in it
EmailHelper email = new EmailHelper();
await email.SendResetPasswordEmail(findMember.Email, expiryTime.ToString("ddMMyyyyHHmmssFFFF"));
}
else
{
ModelState.AddModelError("ForgottenPasswordForm.", "No member found");
return(PartialView("ForgottenPassword", model));
}
return(PartialView("ForgottenPassword", model));
}
public ActionResult HandleForgottenPassword(ForgottenPasswordViewModel vm)
{
// is the model ok?
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
// Do we have a memember with this email address?
// if not, Error
var member = Services.MemberService.GetByEmail(vm.EmailAddress);
if (member == null)
{
ModelState.AddModelError("Error", "Sorry can't find the email in the system");
return(CurrentUmbracoPage());
}
// Create the reset token
var resetToken = Guid.NewGuid().ToString();
//Set the reset expiry date (now + 12 hours)
var expiryDate = DateTime.Now.AddHours(12);
// save memeber
member.SetValue("resetExpiryDate", expiryDate);
member.SetValue("resetLinkToken", resetToken);
Services.MemberService.Save(member);
// Fire the email - reset password
_emailService.SendResetPasswordNotification(vm.EmailAddress, resetToken);
Logger.Info <LoginController>($"Sent a password reset to {vm.EmailAddress}");
// Thanks
TempData["status"] = "OK";
return(RedirectToCurrentUmbracoPage());
}
public ActionResult ChangePassword(string token)
{
return(this.RedirectToAction("ExternalNotify", "Account", new { area = string.Empty }));
Guid guid;
if (!Guid.TryParse(token, out guid))
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid token!");
}
var user = this.Data.Users.All().FirstOrDefault(x => x.ForgottenPasswordToken == guid);
if (user == null)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid token!");
}
var forgottenPasswordModel = new ForgottenPasswordViewModel
{
Token = guid
};
return(this.View(forgottenPasswordModel));
}
/// <summary>
/// Perform the forgotten password process based on the given input model
/// </summary>
/// <param name="inputModel">The forgotten password input model object</param>
/// <returns>Forgotten password view model correctly populated for display, regardless of mode</returns>
public ForgottenPasswordViewModel ForgottenPassword(ForgottenPasswordInputModel inputModel)
{
ForgottenPasswordViewModel viewModel;
switch (inputModel.Mode)
{
case GlobalConstants.PASSWORD_ENC_MODE_INITIAL:
viewModel = new ForgottenPasswordViewModel(true);
viewModel.Mode = GlobalConstants.PASSWORD_ENC_MODE_INITIAL;
break;
case GlobalConstants.PASSWORD_ENC_MODE_USER_SIGNED_IN:
viewModel = new ForgottenPasswordViewModel(true);
viewModel.Mode = GlobalConstants.PASSWORD_ENC_MODE_USER_SIGNED_IN;
break;
case GlobalConstants.PASSWORD_ENC_MODE_RESPONSE:
viewModel = getCustomerDetailsFromBackEnd(inputModel);
break;
default:
viewModel = new ForgottenPasswordViewModel(true);
break;
}
return(viewModel);
}
public async Task <ActionResult> ForgottenPassword(ForgottenPasswordViewModel model)
{
return(await Task.Run <ActionResult>(() =>
{
var response = _registerMediator.ForgottenPassword(model);
ModelState.Clear();
switch (response.Code)
{
case RegisterMediatorCodes.ForgottenPassword.FailedValidation:
response.ValidationResult.AddToModelState(ModelState, string.Empty);
return View(response.ViewModel);
case RegisterMediatorCodes.ForgottenPassword.FailedToSendResetCode:
SetUserMessage(response.Message.Text, response.Message.Level);
return View(response.ViewModel);
case RegisterMediatorCodes.ForgottenPassword.PasswordSent:
UserData.Push(UserDataItemNames.EmailAddress, model.EmailAddress);
return RedirectToAction("ResetPassword");
default:
throw new InvalidMediatorCodeException(response.Code);
}
}));
}
public ActionResult HandleForgottenPassword(ForgottenPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("ForgottenPassword", model));
}
//Find the member with the email address
var findMember = Member.GetMemberFromEmail(model.EmailAddress);
if (findMember != null)
{
//We found the member with that email
//Set expiry date to
DateTime expiryTime = DateTime.Now.AddMinutes(15);
//Lets update resetGUID property
findMember.getProperty("resetGUID").Value = expiryTime.ToString("ddMMyyyyHHmmssFFFF");
//Save the member with the up[dated property value
findMember.Save();
//Send user an email to reset password with GUID in it
EmailHelper email = new EmailHelper();
email.SendResetPasswordEmail(findMember.Email, expiryTime.ToString("ddMMyyyyHHmmssFFFF"));
}
else
{
ModelState.AddModelError("ForgottenPasswordForm.", "No member found");
return(PartialView("ForgottenPassword", model));
}
return(PartialView("ForgottenPassword", model));
}
public async Task <ActionResult> ChangePassword(ForgottenPasswordViewModel model)
{
var user = this.Data.Users.All()
.FirstOrDefault(x => x.ForgottenPasswordToken == model.Token);
if (user == null)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid token!");
}
if (this.ModelState.IsValid)
{
var removePassword = await this.UserManager.RemovePasswordAsync(user.Id);
if (removePassword.Succeeded)
{
var changePassword = await this.UserManager.AddPasswordAsync(user.Id, model.Password);
if (changePassword.Succeeded)
{
user.ForgottenPasswordToken = null;
this.Data.SaveChanges();
this.TempData[GlobalConstants.InfoMessage] = Resources.Account.Views.ChangePasswordView.Password_updated;
return(this.RedirectToAction("Login"));
}
this.AddErrors(changePassword);
}
this.AddErrors(removePassword);
}
return(this.View(model));
}
public bool RequestForgottenPasswordResetCode(ForgottenPasswordViewModel model)
{
_logger.Debug("Calling CandidateServiceProvider to request a password reset code for user {0}",
model.EmailAddress);
try
{
_userAccountService.SendPasswordResetCode(model.EmailAddress);
return(true);
}
catch (CustomException e)
{
switch (e.Code)
{
case Domain.Entities.ErrorCodes.EntityStateError:
case Application.Interfaces.Users.ErrorCodes.UnknownUserError:
_logger.Info(e.Message, e);
break;
default:
_logger.Error(e.Message, e);
break;
}
return(false);
}
catch (Exception e)
{
_logger.Error("Send password reset code failed for " + model.EmailAddress, e);
return(false);
}
}
public ActionResult HandleForgottenPassword(ForgottenPasswordViewModel vm)
{
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
var member = Services.MemberService.GetByEmail(vm.EmailAddress);
if (member == null)
{
ModelState.AddModelError("Forgotten Password", "Member with such an email doesn not exist!");
return(CurrentUmbracoPage());
}
var resetToken = Guid.NewGuid().ToString();
member.SetValue("resetLinkToken", resetToken);
member.SetValue("resetExpiryDate", DateTime.UtcNow.AddMinutes(30));
Services.MemberService.Save(member);
emailService.SendResetPasswordNotification(member.Email, resetToken);
Logger.Info <LoginController>($"Send a password reset to {vm.EmailAddress}");
TempData["status"] = "OK";
return(RedirectToCurrentUmbracoPage());
}
public ActionResult HandleForgottenPassword(ForgottenPasswordViewModel vm)
{
var member = Services.MemberService.GetByEmail(vm.EmailAddress);
if (member == null)
{
ModelState.AddModelError("Error", "Sorry we can't find that email address");
return(CurrentUmbracoPage());
}
var resetToken = Guid.NewGuid().ToString();
var expiryDate = DateTime.Now.AddHours(12);
member.SetValue("resetExpiryDate", expiryDate);
member.SetValue("resetLinkToken", resetToken);
Services.MemberService.Save(member);
_emailService.SendResetPasswordNotification(vm.EmailAddress, resetToken);
Logger.Info <LoginController>($"Sent a password reset to {vm.EmailAddress}");
TempData["status"] = "OK";
return(RedirectToCurrentUmbracoPage());
}
public ActionResult ForgottenPassword(ForgottenPasswordViewModel model)
{
if (ModelState.IsValid)
{
return(View(model));
}
return(View());
}
public void ForgottenPassword(ForgottenPasswordViewModel forgottenPassword)
{
var password = ResolvePouzivatelServiceRepository().GetPouzivatelHeslo(forgottenPassword.Email);
if (password == null)
{
return;
}
ResolveSendMailService().SendEmail(forgottenPassword.Email, password);
}
public ActionResult ForgotPassword(ForgottenPasswordViewModel model)
{
if (!string.IsNullOrEmpty(model.UserName) && !model.AnswerProvided)
{
string domainUser = Sitecore.Context.Domain.GetFullName(model.UserName);
if (!Sitecore.Security.Accounts.User.Exists(domainUser))
{
ViewBag.ErrorMessage = "That user name doesn't exist.";
return(View(model));
}
else
{
var user = System.Web.Security.Membership.GetUser(domainUser);
model.QuestionText = user.PasswordQuestion;
model.AnswerProvided = true;
return(View(ROOT_VIEW_PATH + "Challenge.cshtml", model));
}
}
if (model.AnswerProvided)
{
if (!ModelState.IsValid)
{
ViewBag.ErrorMessage = "Please provide an answer";
return(View(ROOT_VIEW_PATH + "Challenge.cshtml", model));
}
else
{
string domainUser = Sitecore.Context.Domain.GetFullName(model.UserName);
var user = System.Web.Security.Membership.GetUser(domainUser);
try
{
model.NewPassword = user.ResetPassword(model.AnswerText);
//Log them on
Sitecore.Security.Authentication.AuthenticationManager.Login(
domainUser,
model.NewPassword,
false);
return(View(ROOT_VIEW_PATH + "ResetPassword.cshtml", model));
}
catch (Exception ex)
{
ViewBag.ErrorMessage = "The answer supplied is incorrect";
Sitecore.Diagnostics.Log.Error("Error in Forgot Password", ex, this);
return(View(ROOT_VIEW_PATH + "Challenge.cshtml", model));
}
}
}
return(View(model));
}
public void ValidationErrors()
{
var forgottenPasswordViewModel = new ForgottenPasswordViewModel
{
EmailAddress = InvalidEmailAddress
};
var response = _registerMediator.ForgottenPassword(forgottenPasswordViewModel);
response.AssertValidationResult(RegisterMediatorCodes.ForgottenPassword.FailedValidation, true);
}
public void PasswordSent()
{
var forgottenPasswordViewModel = new ForgottenPasswordViewModel
{
EmailAddress = ValidEmailAddress
};
_candidateServiceProvider.Setup(
csp => csp.RequestForgottenPasswordResetCode(It.IsAny <ForgottenPasswordViewModel>())).Returns(true);
var response = _registerMediator.ForgottenPassword(forgottenPasswordViewModel);
response.AssertCode(RegisterMediatorCodes.ForgottenPassword.PasswordSent, true);
}
public void PasswordNotSent()
{
var forgottenPasswordViewModel = new ForgottenPasswordViewModel
{
EmailAddress = ValidEmailAddress
};
_candidateServiceProvider.Setup(
csp => csp.RequestForgottenPasswordResetCode(It.IsAny <ForgottenPasswordViewModel>())).Returns(false);
var response = _registerMediator.ForgottenPassword(forgottenPasswordViewModel);
response.AssertMessage(RegisterMediatorCodes.ForgottenPassword.FailedToSendResetCode,
PasswordResetPageMessages.FailedToSendPasswordResetCode, UserMessageLevel.Warning, true);
}
public MediatorResponse <ForgottenPasswordViewModel> ForgottenPassword(ForgottenPasswordViewModel forgottenPasswordViewModel)
{
var validationResult = _forgottenPasswordViewModelServerValidator.Validate(forgottenPasswordViewModel);
if (!validationResult.IsValid)
{
return(GetMediatorResponse(RegisterMediatorCodes.ForgottenPassword.FailedValidation, forgottenPasswordViewModel, validationResult));
}
if (_candidateServiceProvider.RequestForgottenPasswordResetCode(forgottenPasswordViewModel))
{
return(GetMediatorResponse(RegisterMediatorCodes.ForgottenPassword.PasswordSent, forgottenPasswordViewModel));
}
return(GetMediatorResponse(RegisterMediatorCodes.ForgottenPassword.FailedToSendResetCode, forgottenPasswordViewModel, PasswordResetPageMessages.FailedToSendPasswordResetCode, UserMessageLevel.Warning));
}
public void ValidationErrors()
{
var forgottenPasswordViewModel = new ForgottenPasswordViewModel
{
EmailAddress = InvalidEmailAddress
};
var mediator = new LoginMediatorBuilder().Build();
var response =
mediator.ForgottenPassword(new ForgottenCredentialsViewModel
{
ForgottenPasswordViewModel = forgottenPasswordViewModel
});
response.AssertValidationResult(LoginMediatorCodes.ForgottenPassword.FailedValidation, true);
}
public IActionResult ForgottenPassword(ForgottenPasswordViewModel forgottenPassViewModel)
{
if (ModelState.IsValid)
{
SQLInjectionProtectionService sQLInjectionProtectionService = new SQLInjectionProtectionService();
if (sQLInjectionProtectionService.HasMaliciousCharacters(forgottenPassViewModel.Email))
{
ViewData["MaliciousSymbols"] = Constant.MaliciousSymbols;
return(View());
}
if (db.Accounts.FirstOrDefault(x => x.Email == forgottenPassViewModel.Email) != null)
{
this.TempData["SentEmail"] = Constant.SentEmail;
return(RedirectToAction("ForgottenPassword"));
}
}
this.TempData["NotMatchingEmail"] = Constant.NotMatchingEmail;
return(View());
}
public ActionResult ForgottenPassword(ForgottenPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var user = _userRepository.Users.FirstOrDefault(u => u.Email == model.Email);
if (user == null)
{
return(RedirectToAction("Login"));
}
var newPasssword = _userRepository.ResetPassword(user.Id);
var body = $"Twoje hasło zostało zmienione na {newPasssword}\nMożesz teraz sie zalogować używając tego hasła";
_emailSender.SendMessage(user.Email, "Resetowanie hasła", body);
return(RedirectToAction("Login"));
}
public void PasswordSent()
{
var forgottenPasswordViewModel = new ForgottenPasswordViewModel
{
EmailAddress = ValidEmailAddress
};
var candidateServiceProvider = new Mock <ICandidateServiceProvider>();
candidateServiceProvider.Setup(
csp => csp.RequestForgottenPasswordResetCode(It.IsAny <ForgottenPasswordViewModel>())).Returns(true);
var mediator = new LoginMediatorBuilder().With(candidateServiceProvider).Build();
var response =
mediator.ForgottenPassword(new ForgottenCredentialsViewModel
{
ForgottenPasswordViewModel = forgottenPasswordViewModel
});
response.AssertCode(LoginMediatorCodes.ForgottenPassword.PasswordSent, true);
}
public ActionResult Forgot(ForgottenPasswordViewModel forgottenPasswordViewModel)
{
if (!this.ModelState.IsValid)
{
return(this.View("Forgot", forgottenPasswordViewModel));
}
if (forgottenPasswordViewModel == null)
{
throw new ArgumentNullException("forgottenPasswordViewModel");
}
var user = this.userService.GetUserByUserName(forgottenPasswordViewModel.UserName);
if (user == null)
{
this.ModelState.AddModelError("UserName", "We don't have a record of that email or user name.");
return(this.View("Forgot", forgottenPasswordViewModel));
}
if (user is Child)
{
var parent = this.userService.GetUser(((Child)user).ParentId);
if (parent == null)
{
throw new TardisBankException("Missing parent: {0}", ((Child)user).ParentId);
}
this.SendPasswordResetEmail(user, toAddress: parent.UserName);
return(this.RedirectToAction("ChildConfirm"));
}
if (user is Parent)
{
this.SendPasswordResetEmail(user, toAddress: user.UserName);
return(this.RedirectToAction("ParentConfirm"));
}
throw new TardisBankException("unknown User subtype");
}
public ActionResult HandleForgottenPassword(ForgottenPasswordViewModel model)
{
var membershipService = ApplicationContext.Current.Services.MemberService;
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
//Find the member with the email address
var findMember = membershipService.GetByEmail(model.EmailAddress);
if (findMember == null)
{
//Don't tell user we were unable to find their email address...
TempData["IsSuccessful"] = true;
return(CurrentUmbracoPage());
}
//We found the member with that email
//Set expiry date to
DateTime expiryTime = DateTime.Now.AddMinutes(15);
//Lets update resetGUID property
findMember.Properties["resetGUID"].Value = expiryTime.ToString("ddMMyyyyHHmmssFFFF");
//Save the member with the up[dated property value
membershipService.Save(findMember);
//Send user an email to reset password with GUID in it
EmailHelper email = new EmailHelper();
email.SendResetPasswordEmail(findMember.Email, expiryTime.ToString("ddMMyyyyHHmmssFFFF"));
TempData["IsSuccessful"] = true;
return(CurrentUmbracoPage());
}
public async Task <ActionResult> ResendPasswordResetCode(string emailAddress)
{
return(await Task.Run(() =>
{
var model = new ForgottenPasswordViewModel {
EmailAddress = emailAddress
};
UserData.Push(UserDataItemNames.EmailAddress, model.EmailAddress);
if (_candidateServiceProvider.RequestForgottenPasswordResetCode(model))
{
SetUserMessage(string.Format(PasswordResetPageMessages.PasswordResetSent, emailAddress));
}
else
{
SetUserMessage(PasswordResetPageMessages.FailedToSendPasswordResetCode, UserMessageLevel.Warning);
}
return RedirectToRoute(RouteNames.ResetPassword);
}));
}
public ActionResult ForgottenPassword(ForgottenPasswordViewModel model)
{
// Validate captcha control
if (!captchaService.Validate(Request["g-recaptcha-response"]))
{
ModelState.AddModelError(string.Empty, Resource.WrongCaptchaMessage);
}
if (!ModelState.IsValid)
{
return(Json(
new { success = false, result = RenderRazorViewToString("_ForgottenPassword", model) },
JsonRequestBehavior.AllowGet));
}
User user;
using (ContextManager.NewConnection())
{
user = accountService.GetByUserName(model.UserName);
}
if (user == null)
{
throw new UserException(Resource.UserNotFound);
}
if (user.Status.Id != EnumHelper.GetStatusIdByEnum(UserStatus.Active))
{
throw new UserException(Resource.ActivateYourAccount);
}
userMailService.SendChangePasswordMail(user);
this.ShowMessage(MessageType.Success, Resource.ForgottenPasswordLinkSuccess);
return(Json(new { success = true, result = user }, JsonRequestBehavior.AllowGet));
}
public ActionResult HandleForgottenPassword(ForgottenPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
//Find the member with the email address
var findMember = Member.GetMemberFromEmail(model.EmailAddress);
if (findMember != null)
{
//We found the member with that email
//Set expiry date to
DateTime expiryTime = DateTime.Now.AddMinutes(15);
//Lets update resetGUID property
findMember.getProperty("resetGUID").Value = expiryTime.ToString("ddMMyyyyHHmmssFFFF");
//Save the member with the up[dated property value
findMember.Save();
//Get Email Settings from Forgotten Password Node (current node)
var emailFrom = CurrentPage.GetPropertyValue("emailFrom", "*****@*****.**").ToString();
var emailSubject = CurrentPage.GetPropertyValue("emailSubject", "CWS - Forgotten Password").ToString();
//Send user an email to reset password with GUID in it
EmailHelper.SendResetPasswordEmail(findMember.Email, emailFrom, emailSubject, expiryTime.ToString("ddMMyyyyHHmmssFFFF"));
}
else
{
ModelState.AddModelError("ForgottenPasswordForm.", "No member found");
return(CurrentUmbracoPage());
}
return(RedirectToCurrentUmbracoPage());
}
public ActionResult HandleForgottenPassword(ForgottenPasswordViewModel model)
{
var membershipService = ApplicationContext.Current.Services.MemberService;
if (!ModelState.IsValid)
{
return CurrentUmbracoPage();
}
//Find the member with the email address
var findMember = membershipService.GetByEmail(model.EmailAddress);
if (findMember != null)
{
//We found the member with that email
//Set expiry date to
DateTime expiryTime = DateTime.Now.AddMinutes(15);
//Lets update resetGUID property
findMember.Properties["resetGUID"].Value = expiryTime.ToString("ddMMyyyyHHmmssFFFF");
//Save the member with the up[dated property value
membershipService.Save(findMember);
//Send user an email to reset password with GUID in it
EmailHelper email = new EmailHelper();
email.SendResetPasswordEmail(findMember.Email, expiryTime.ToString("ddMMyyyyHHmmssFFFF"));
}
else
{
ModelState.AddModelError("ForgottenPasswordForm.", "No member found");
return CurrentUmbracoPage();
}
return RedirectToCurrentUmbracoPage();
}
//[ValidateAntiForgeryToken]
public async Task <ActionResult> HandleForgottenPassword(ForgottenPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(Json(new
{
Success = false,
ErrorMessage = "Please check your details entered again.",
}));
}
// the process should take care of Facebook user id.
// get member with email
var member = Members.GetByEmail(model.EmailAddress);
if (member == null)
{
// try get it through username.
member = Members.GetByUsername(model.EmailAddress);
}
if (member != null)
{
// Get the details of the user currently logged in
var currentMember = Members.GetCurrentMember();
if (currentMember != null &&
currentMember.Email().Trim().ToLowerInvariant() != model.EmailAddress.Trim().ToLowerInvariant())
{
LogHelper.Error(typeof(AuthSurfaceController),
$"Possible fraud, logged in member: {currentMember.Email()}, username:{currentMember.UserName()}, try reset password of other Member: {model.EmailAddress}", new InvalidOperationException("Fraud"));
return(Json(new { Success = false }));
}
// if its a facebook user cannot reset password!
var fbUserId = member.GetPropertyValue <string>("facebookUserId");
if (!string.IsNullOrEmpty(fbUserId))
{
return(Json(new
{
ErrorMessage = "Facebook members cannot change password!",
Success = false,
}));
}
var expiryTime = DateTime.UtcNow.AddMinutes(ExpirePasswordMinutes);
var hash = $"{HashHelper.GetSHA256Hash(member.Email())}__{expiryTime.Ticks}";
// update password hash
var resetMember = Services.MemberService.GetById(member.Id);
resetMember.SetValue("passwordResetHash", hash);
Services.MemberService.Save(resetMember);
await EmailHelper.SendResetPasswordEmail(Umbraco, resetMember, hash, CurrentPage);
return(Json(new
{
Success = true,
ErrorMessage = "A reset password email had been sent to your email account. Please check.",
}));
}
else
{
return(Json(new
{
Success = false,
ErrorMessage = "No member found with this credentials.",
}));
}
}
public ActionResult HandleForgottenPassword(ForgottenPasswordViewModel model)
{
var membershipService = Services.MemberService;
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
//Find the member with the email address
var findMember = membershipService.GetByEmail(model.EmailAddress);
if (findMember != null)
{
// This test is an absolute car wreck. Umbraco stores the field as a 1 or a null value, hence the tryparse. I'm tired I cant think
bool newMember;
int newMemberInt;
// Get the new member status
if (findMember.HasProperty("newMember") && Int32.TryParse(findMember.Properties["newMember"].GetValue().ToString(), out newMemberInt))
{
if (newMemberInt == 1)
{
newMember = true;
}
else
{
newMember = false;
}
}
else
{
newMember = false;
}
// Time the password reset link expires
DateTime expiryTime;
// Generate a password reset token
string resetToken = tokenHelper.GetUniqueToken(64);
//IF this is a new member, set the expiry time to 24 hours
if (newMember)
{
expiryTime = DateTime.Now.AddHours(24);
}
else
{
expiryTime = DateTime.Now.AddMinutes(15);
}
//Set the token expiry time.
findMember.Properties["passwordResetExpiry"].SetValue(expiryTime.ToString("ddMMyyyyHHmmssFFFF"));
// Save the hash of the reset token to the database.
findMember.Properties["passwordResetTokenHash"].SetValue(tokenHelper.GetHash(resetToken));
//Save the member with the updated property value
membershipService.Save(findMember);
//Send user an email to reset password with GUID in it
EmailHelper email = new EmailHelper();
email.SendResetPasswordEmail(findMember.Email, resetToken, newMember, findMember.Name);
TempData["ResetEmailSent"] = true;
}
else
{
ModelState.AddModelError("ForgottenPasswordForm.", "No member found");
return(CurrentUmbracoPage());
}
return(RedirectToCurrentUmbracoPage());
}
/// <summary>
/// Perform the customer details retrieval process and return a view model with error handling
/// </summary>
/// <param name="inputModel">The forgotten password input model object</param>
/// <returns>Forgotten password view model correctly populated for display</returns>
private ForgottenPasswordViewModel getCustomerDetailsFromBackEnd(ForgottenPasswordInputModel inputModel)
{
ErrorObj talentErrObj = new ErrorObj();
DECustomer deCust = new DECustomer();
Mapper.CreateMap <ForgottenPasswordInputModel, DECustomer>();
DECustomerV11 deCustV11 = new DECustomerV11();
ForgottenPasswordViewModel viewModel = new ForgottenPasswordViewModel(true);
deCust = Mapper.Map <DECustomer>(inputModel);
deCust.Source = GlobalConstants.SOURCE;
deCustV11.DECustomersV1.Add(deCust);
_talCust.DeV11 = deCustV11;
_talCust.Settings = Environment.Settings.DESettings;
talentErrObj = _talCust.CustomerRetrieval();
viewModel.Error = Data.PopulateErrorObject(talentErrObj, _talCust.ResultDataSet, _talCust.Settings, 2);
if (!viewModel.Error.HasError)
{
//Add the tokens to the result Set
_dtCustomerResults = _talCust.ResultDataSet.Tables["CustomerResults"];
if (_dtCustomerResults.Rows.Count == 1)
{
_doTokenHashing = inputModel.DoTokenHashing;
checkCustomerTokens();
if (generateResetTokens())
{
if (generateTableRecords())
{
generateEmail();
viewModel.Mode = GlobalConstants.PASSWORD_ENC_MODE_RESPONSE;
}
else
{
viewModel.Mode = GlobalConstants.PASSWORD_ENC_MODE_INITIAL;
viewModel.Error.HasError = true;
viewModel.Error.ErrorMessage = viewModel.GetPageText("UnspecifiedError");
_talCust.Settings.Logging.ErrorObjectLog("ForgottenPassword.aspx - Reset Password email", "FPW", "Cannot create reset password table records", "PasswordEncryptionLog");
}
}
else
{
viewModel.Mode = GlobalConstants.PASSWORD_ENC_MODE_INITIAL;
viewModel.Error.HasError = true;
viewModel.Error.ErrorMessage = viewModel.GetPageText("UnspecifiedError");
_talCust.Settings.Logging.ErrorObjectLog("ForgottenPassword.aspx - Reset Password email", "FPW", "Cannot create reset password tokens", "PasswordEncryptionLog");
}
}
else
{
viewModel.Mode = GlobalConstants.PASSWORD_ENC_MODE_INITIAL;
viewModel.Error.HasError = true;
viewModel.Error.ErrorMessage = viewModel.GetPageText("UnspecifiedError");
_talCust.Settings.Logging.ErrorObjectLog("ForgottenPassword.aspx - Reset Password email", "FPW", "No customer records have been returned from WS009R", "PasswordEncryptionLog");
}
}
else
{
viewModel.Mode = GlobalConstants.PASSWORD_ENC_MODE_INITIAL;
_talCust.Settings.Logging.ErrorObjectLog("ForgottenPassword.aspx - Reset Password email", "FPW", viewModel.Error.ErrorMessage, "PasswordEncryptionLog");
}
return(viewModel);
}
public ActionResult RenderForgottenPAssword()
{
var vm = new ForgottenPasswordViewModel();
return(PartialView(PARTIAL_VIEW_FOLDER + "ForgottenPassword.cshtml", vm));
}
