public ActionResult Update(ResetPassword Model)
{
return Dispatcher.Update(
DataModel: Model,
SuccessResult: m => RedirectToAction("Index", "Home"),
InvalidResult: m => View(m));
}
public virtual async Task<ActionResult> Post(ResetPassword command, string returnUrl, string emailAddress)
{
//System.Threading.Thread.Sleep(new Random().Next(5000, 5001));
if (command == null || string.IsNullOrWhiteSpace(emailAddress))
return View(MVC.Errors.Views.BadRequest);
var verification = await _queries.Execute(new EmailVerificationBy(command.Ticket));
if (verification == null) return HttpNotFound();
if (!ModelState.IsValid)
{
ViewBag.EmailAddress = emailAddress;
ViewBag.Ticket = command.Ticket;
ViewBag.Token = command.Token;
ViewBag.ReturnUrl = returnUrl;
return View(MVC.Security.Views.ResetPassword.ResetPassword, command);
}
await _commands.Execute(command);
var signIn = new SignIn
{
UserNameOrVerifiedEmail = verification.EmailAddress.Value,
Password = command.Password
};
await _commands.Execute(signIn);
Session.VerifyEmailTickets(null);
Response.ClientCookie(signIn.SignedIn.Id, _queries);
return this.RedirectToLocal(returnUrl, await MVC.UserName.Index());
}
private void _resetPassword(ResetPassword request, Action<DriverAuthorizationResult> onSuccess, Action<GeneralFailureCode> onFailure) {
if (request.ClientId == null || request.RegistrationCode.IsEmpty()) {
Log.Warn("Driver registration: Attempt to reset password with bad arguments. UserId:{0}, UserSsn:{1}", request.ClientId, request.RegistrationCode);
onFailure(GeneralFailureCode.InvalidData);
} else {
var loginName = AuthServices.GetLoginName(request.ClientId);
if (loginName.NotEmpty()) {
var roles = AuthServices.GetClientRoles(loginName);
if (roles != null) {
if (roles.Contains(BplRole.Get(OscarRoles.Driver))) {
_checkDriver(request.ClientId, request.RegistrationCode, AuthorizationSessionKind.ResetPassword, onSuccess, r => onFailure(r.Error));
} else {
Log.Warn("Driver registration: {0} is {1}. Reset password is not supported yet.", request.ClientId, roles.FirstOrDefault());
onFailure(GeneralFailureCode.InvalidData);
}
} else {
Log.Warn("Driver registration: Unable to retrive client {0} role.", request.ClientId);
onFailure(GeneralFailureCode.InvalidData);
}
} else {
Log.Warn("Driver registration: Client {0} was not found for password reset.", request.ClientId);
onFailure(GeneralFailureCode.InvalidData);
}
}
}
public async Task<ActionResult> ResetPassword(ResetPassword model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
if (!ModelState.IsValid)
{
return View(model);
}
if (await membershipService.ResetPassword(
model.Token,
model.Password))
{
Flash[FlashMessageType.Success] = "Your password is " +
"successfully changed.";
}
else
{
Flash[FlashMessageType.Error] = "Invalid reset token, " +
"you may have miss typed the token or the token has " +
"expired.";
}
return RedirectToHome();
}
public void GivenAnonymousPostRequest_WithInvalidId_Redirects()
{
var model = new ResetPassword
{
Token = Guid.NewGuid()
};
var result = Controller.ResetPassword(model) as RedirectResult;
result.Should().Not.Be.Null();
result.Url.Should().Equal(Controller.Url.Account().ForgotPassword());
var notification = Controller.TempData[ViewDataConstants.Notification] as Notification;
notification.Should().Not.Be.Null();
}
public virtual ActionResult Validate(ResetPassword command, string fieldName = null)
{
//System.Threading.Thread.Sleep(new Random().Next(5000, 5001));
if (command == null)
{
Response.StatusCode = 400;
return Json(null);
}
var result = new ValidatedFields(ModelState, fieldName);
//ModelState[command.PropertyName(x => x.UserName)].Errors.Clear();
//result = new ValidatedFields(ModelState, fieldName);
return new CamelCaseJsonResult(result);
}
public async Task <IActionResult> ResetPassword(ResetPassword resetPassword)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByEmailAsync(resetPassword.Email);
if (user == null)
{
return(BadRequest(ModelState));
}
var resetPassResult = await _userManager.ResetPasswordAsync(user, resetPassword.Token, resetPassword.Password);
if (!resetPassResult.Succeeded)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <bool> ResetPassword(ResetPassword model)
{
var user = await _unitOfWork.UserManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(false);
}
var result = await _unitOfWork.UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
if (result.Succeeded)
{
_logger.Info($"The password for {model.Email} was reseted");
return(true);
}
throw new Exception("Cannot change the password");
}
public async Task ResetPasswordReturnsNoContentIfCodeIsValid()
{
var userManager = TestHelpers.CreateUserManagerWithUser(out var testUser);
var controller = CreateController(userManager);
var code = await userManager.GeneratePasswordResetTokenAsync(testUser);
var resetPassword = new ResetPassword
{
UserId = testUser.Id,
NewPassword = "******",
Code = code
};
var res = await controller.ResetPassword(resetPassword);
res.Should().BeOfType <NoContentResult>();
(await userManager.CheckPasswordAsync(testUser, resetPassword.NewPassword)).Should().BeTrue();
}
public String GetResetPassword(String ResetPasswordvalue)
{
String Msg = String.Empty;
ResetPassword resetPassword = Users.GetResetPassword(ResetPasswordvalue);
Msg = resetPassword.Message;
if (resetPassword.Message.Contains("Sucessfull"))
{
var issent = SendPasswordResetEmail(resetPassword.Email, resetPassword.Username, resetPassword.UniqueId);
if (issent)
{
Msg = "An email with instructions to reset your password is sent to " + resetPassword.Email;
}
else
{
Msg = "Due to internal error a email with instructions failed to send to " + resetPassword.Email;
}
}
return(Msg);
}
private IResult CreatePasswordResetToken(string Email)
{
var user = _userService.GetByEmail(Email);
if (user != null)
{
var token = Guid.NewGuid().ToString();
var expirationTime = DateTime.Now.AddDays(1);
var resetUser = new ResetPassword
{
UserId = user.Id,
Token = token,
ExpirationTime = expirationTime
};
_sifreYenilemeDal.Add(resetUser);
return(new SuccessResult());
}
_loggerService.Info("CreatePasswordResetToken: " + "UserNotFound");
return(new ErrorResult("UserNotFound"));
}
public async Task <ActionResult> ResetPassword(ResetPassword model)
{
if (!Data.CheckPasswordResetRequest(model.RequestId))
{
ModelState.AddModelError("", "Request ID is invalid. It might have been used already.");
}
if (!ModelState.IsValid)
{
return(View(new ResetPassword()));
}
var user = Data.ResetPassword(model.RequestId, model.NewPass);
await SetAuthCookieAsync(user.Name, createPersistentCookie : false);
TempData.SetStatusMessage("Password reset successfully!");
return(RedirectToAction("Index", "Home"));
}
public ActionResult AuthenticateResetPassword(string token)
{
DataManager dm = new DataManager();
//validate token
var m = dm.ValidateToken(token, 1440);
//does it exist
//has it expired
if (m == null)
{
dm.TryInvalidateToken(token);
TempData["ErrorMessage"] = "We could not validate you on the system. This could be because the token is invalid. Please try again.";
return(PartialView("ResetPasswordForm", new ResetPassword()));
}
ResetPassword model = new ResetPassword();
model.Token = token;
return(PartialView("ResetPasswordForm", model));
}
public ActionResult Reset(string email)
{
var user = _usersService.GetByEmail(email);
if (user == null)
{
ModelState.AddModelError("email", "User with this email is not registred.");
}
if (ModelState.IsValid)
{
var newPass = GenerateNewPassword(7);
var cmd = new ResetPassword
{
Id = email
};
Send(cmd);
return(Redirect("/"));
}
return(View("Forgot", (object)email));
}
public async Task <IActionResult> Activate([FromBody] ResetPassword model)
{
var isActivate = await AuthenticationService.IsUserActive(model.UserName);
if (isActivate)
{
return(BadRequest(new Result("", "User Account has already been activated").ValidationFailures));
}
var result = await AuthenticationService.ResetPassword(model);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
result.Tag = await AuthenticationService.GenerateToken(model.UserName, JwtOptions);
return(Ok(result));
}
public IHttpActionResult Delete([FromBody] ResetPassword resetPassword, [FromUri] string lang = "en")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ResetPasswordService resetPasswordService = new ResetPasswordService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
if (!resetPasswordService.Delete(resetPassword))
{
return(BadRequest(String.Join("|||", resetPassword.ValidationResults)));
}
else
{
resetPassword.ValidationResults = null;
return(Ok(resetPassword));
}
}
}
public async Task <IActionResult> ForgotPassword(ResetPassword model)
{
if (ModelState.IsValid)
{
var user = await userManager.FindByEmailAsync(model.Email);
if (user != null && user.EmailConfirmed)
{
var token = await userManager.GeneratePasswordResetTokenAsync(user);
var passwordResetLink = Url.Action("ResetPassword", "Account",
new { email = model.Email, token = token }, Request.Scheme);
ViewBag.message = "Reset Link: " + passwordResetLink;
return(View("ForgotPasswordConfirmation"));
}
return(View("ForgotPasswordConfirmation"));
}
return(View(model));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
using HttpClient client = _httpClientFactory.CreateClient(_configuration["ApplicationIds:IdManagementId"]);
client.BaseAddress = new Uri(_configuration["AppURLS:IdApiBaseUrl"]);
string asJson = JsonSerializer.Serialize <ForgotPasswordViewModel>(model);
StringContent content = new StringContent(asJson, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync("/api/v1/Account/ForgotPasswordAsync", content);
if (!response.IsSuccessStatusCode)
{
_logger.LogError("~/Account/ForgotPassword(ForgotPasswordViewModel) - An error occurred with the Http Response Message. Response:{0}", response);
throw new HttpRequestException($"An error occurred attempting to reset the password on the account with the email address: {model.Email}");
}
string responseContent = await response.Content.ReadAsStringAsync();
ResetPassword forgotPasswordObj = JsonSerializer.Deserialize <ResetPassword>(responseContent);
response.EnsureSuccessStatusCode();
var callbackUrl = Url.ResetPasswordCallbackLink(forgotPasswordObj.Code, Request.Scheme);
try
{
await _emailSender.SendEmailAsync(model.Email, "Reset Your Password", $"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
}
catch (SmtpException ex)
{
_logger.LogError("An error occurred sending Password reset email for User Email:{0}, Error:{1}, Error Message{2}, Stack Trace:{3}", forgotPasswordObj.Email, ex, ex.Message, ex.StackTrace);
throw;
}
return(RedirectToAction(nameof(ForgotPasswordConfirmation)));
}
public async Task <ActionResult <ItemResponse <int> > > ResetPassword(ResetPassword model)
{
int iCode = 200;
BaseResponse response = null;
int userId = 0;
bool isSuccessful = false;
try
{
userId = _authService.GetCurrentUserId();
isSuccessful = _service.ResetPassword(model, userId);
if (isSuccessful == true)
{
try
{
await _authService.LogOutAsync();
}
catch (Exception ex)
{
iCode = 500;
base.Logger.LogError(ex.ToString());
response = new ErrorResponse($"Logout Error: {ex.Message}");
}
response = new SuccessResponse();
}
else
{
iCode = 404;
response = new ErrorResponse("Resource Not Found");
}
}
catch (Exception ex1)
{
iCode = 500;
base.Logger.LogError(ex1.ToString());
response = new ErrorResponse($"Server Error: {ex1.Message}");
}
return(StatusCode(iCode, response));
}
public async Task <IActionResult> OnPostAsync()
{
if (this.ModelState.IsValid)
{
// Deliberately slow this method down slightly to avoid leaking information via time taken
await Task.Delay(TimeSpan.FromMilliseconds(new Random().Next(200)));
var user = await this.userManager.FindByEmailAsync(this.Input.Email);
if (user == null || !(await this.userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(this.RedirectToPage("./ForgotPasswordConfirmation"));
}
var code = await this.userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = this.Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: new { code },
protocol: "https");
var ipAddress = this.httpContextAccessor.GetOriginatingIpAddress();
var resetPasswordEmail = new ResetPassword(this.Input.Email, callbackUrl, ipAddress);
var recentlySent = this.emailRepository
.GetRecent()
.Any(e => e.To == resetPasswordEmail.To && e.Subject == resetPasswordEmail.Subject);
if (!recentlySent)
{
this.emailRepository.AddToQueue(resetPasswordEmail);
}
return(this.RedirectToPage("./ForgotPasswordConfirmation"));
}
return(this.Page());
}
public async Task <IActionResult> ResetPassword(ResetPassword model)
{
if (ModelState.IsValid)
{
model.Token = model.Token.Replace(' ', '+');
var result = await _accountRepository.ResetPasswordAsync(model);
if (result.Succeeded)
{
ModelState.Clear();
model.IsSuccess = true;
return(View(model));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> ResetPassword(string id)
{
IEnumerable <RoleViewModel> lstRoles = await ApiInvoker.GetAsync <IEnumerable <RoleViewModel> >(APIURL.IdentityBaseUri + IdentityAPI.Role.GetAll);
var objParam = new
{
id = id
};
UserEditGetModel user = await ApiInvoker.PostAsync <UserEditGetModel>(objParam, APIURL.IdentityBaseUri + IdentityAPI.User.GetByID);
ResetPassword reset = new ResetPassword();
if (user != null)
{
reset.UserName = user.UserName;
}
Dictionary <string, string> _localLabel = await LocalizeData(LocalizePath);
ViewData["LocalLabel"] = _localLabel;
return(View("ResetPassword", reset));
}
public ActionResult RestPassword(ResetPassword resetPassword)
{
int uid = Convert.ToInt32(Session["Id"]);
Users UserIndDb = db.Users.Single(e => e.Id == uid);
if (UserIndDb.UserPass == resetPassword.CurrentPassword && resetPassword.NewPassword.Length >= 8)
{
UserIndDb.UserPass = resetPassword.NewPassword;
db.SaveChanges();
Session["message"] = "successfully new pass ";
}
else
{
Session["message"] = "invalid";
}
return(RedirectToAction("UserProfile", new { id = UserIndDb.Id }));
}
public ActionResult ResetPassword(string id)
{
BGBC.Web.Models.ResetPassword reset = new ResetPassword();
try
{
PasswordReset pwd = passwordresetRepo.Get().Where(x => x.Token == id).FirstOrDefault();
if (pwd == null)
{
ViewBag.ValidEmail = false;
}
else
{
reset.TokenID = id; ViewBag.ValidEmail = true;
}
}
catch (Exception ex)
{
log.Error(ex.Message);
}
return(View(reset));
}
public IHttpActionResult ResetPassword(ResetPassword resetPassword)
{
if (resetPassword.Key != "123")
{
return Content(HttpStatusCode.Forbidden, "Code is wrong");
}
if (resetPassword.Password != resetPassword.PasswordConfirm)
{
return Content(HttpStatusCode.Forbidden, "Password is not matched");
}
var user = _userService.GetByUserNameActive(resetPassword.UserName);
user.Password = PasswordHash.GetPass(resetPassword.Password);
_userService.UpdatePassword(user);
return Ok(new
{
data = "Ok"
});
}
public void GivenAnonymousPostRequest_WithValidData_LogsInUser()
{
var expectedObject = new PasswordRetrieval
{
Token = Guid.NewGuid(),
UserId = User.Id
};
Db.Save(expectedObject);
var model = new ResetPassword
{
Token = expectedObject.Token,
Password = "******" + GetRandom.String(10),
};
model.PasswordConfirm = model.Password;
Controller.ResetPassword(model);
AuthenticationService.Verify(x => x.SetLoginCookie(It.Is <User>(u => u.Id == User.Id), true), Times.Once());
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPassword model)
{
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
return(this.Ok());
}
var result = await UserManager.ResetPasswordAsync(user, model.Code, model.Password);
if (result.Succeeded)
{
return(this.Ok());
}
return(this.BadRequest(new
{
Email = result.Errors.Where(e => e.Code.ToLower().Contains("email")).Select(x => x.Code).ToList(),
Password = result.Errors.Where(e => e.Code.ToLower().Contains("password")).Select(x => x.Code).ToList(),
}));
}
public async Task resetpassword_command_should_fail_if_user_does_not_exist()
{
var id = new AggregateId();
var email = "*****@*****.**";
var fullname = "fullname";
var password = "******";
var newPassword = "******";
var pic = "test.nl/image";
var role = Role.User;
var securityStamp = new Guid().ToString();
// generate reset token
var token = await _dataProtectorTokenProvider.GenerateAsync(Purpose, id, securityStamp);
var command = new ResetPassword(id, newPassword, token);
_commandHandler
.Awaiting(c => c.HandleAsync(command))
.Should().Throw <UserNotFoundException>();
}
public string ObtenerCodigoRestablecerPassword(string email)
{
ResetPassword C = new ResetPassword();
try
{
using (SudokuContext Context = new SudokuContext())
{
C = Context.ResetPassword.Where(x => x.Email == email && x.Estatus == false).OrderByDescending(x => x.Id).Take(1).FirstOrDefault();
if (C != null)
{
return(C.Codigo);
}
}
}
catch (Exception ex)
{
InsertarSucesoLog(Funcion.ConstruirSucesoLog(ex.ToString().Substring(0, 300) + "*EngineDb/ObtenerCodigoRestablecerPassword*" + email));
}
return(string.Empty);
}
public IActionResult ChangePassword(string id)
{
if (id == null)
{
return(NotFound());
}
var member = _security.GetMemberByApplicationId(id);
if (member == null)
{
return(NotFound());
}
ResetPassword cp = new ResetPassword();
cp.Id = id;
cp.UserName = member.UserName;
return(View(cp));
}
public ActionResult ResetPassword(ResetPassword model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (resetPassword(model.Token, model.Password))
{
Flash[FlashMessageType.Success] = "Your password is " +
"successfully changed.";
}
else
{
Flash[FlashMessageType.Error] = "Invalid reset token, " +
"you may have miss typed the token or the token has " +
"expired.";
}
return(RedirectToHome());
}
public async Task ResetPassword_ResetPasswordModel_Exception()
{
var email = "*****@*****.**";
var id = "1";
var resetPassword = new ResetPassword {
Email = email
};
var user = new IdentityUser()
{
Email = email, Id = id
};
var userStore = Mock.Of <IUserStore <IdentityUser> >();
var userManager = new Mock <ApplicationUserManager>(userStore);
var identityResult = IdentityResult.Failed(null);
userManager.Setup(_ => _.FindByEmailAsync(email)).Returns(Task.FromResult(user));
userManager.Setup(_ => _.ResetPasswordAsync(id, It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(identityResult));
_unitOfWorkMock.SetupGet(uof => uof.UserManager).Returns(userManager.Object);
await Assert.ThrowsAsync <Exception>(() => _sut.ResetPassword(resetPassword));
}
public ActionResult ResetPassword(ResetPassword model)
{
if (!ModelState.IsValid)
{
return View(model);
}
if (resetPassword(model.Token, model.Password))
{
Flash[FlashMessageType.Success] = "Your password is " +
"successfully changed.";
}
else
{
Flash[FlashMessageType.Error] = "Invalid reset token, " +
"you may have miss typed the token or the token has " +
"expired.";
}
return RedirectToHome();
}
public ActionResult Edit([Bind(Include = "email,old_password,password,confirm_password")] ResetPassword user)
{
try
{
// TODO: Add update logic here
var the_user = db.Account.Find(user.email);
if (the_user != null && the_user.Password == user.old_password)
{
if (user.password == user.confirm_password)
{
the_user.Password = user.password;
db.SaveChanges();
}
}
return(RedirectToRoute("default"));
}
catch
{
return(View());
}
}
public ActionResult ResetPassword(ResetPassword model, string ReturnUrl = "")
{
string message = "";
bool Status = false;
string type = "Success";
using (MyDatabaseEntities dc = new MyDatabaseEntities())
{
var user = dc.Users.Where(x => x.EmailID == model.EmailID).FirstOrDefault();
if (!user.Locked)
{
message = "your account has not been locked please try forgotten password.";
type = "Error";
Status = true;
}
else
{
if (user != null)
{
if (SendReActiveMail(user))
{
message = "Request has been sent to admin.";
type = "Success";
Status = true;
}
else
{
message = "Request has not been sent to admin. try writing a mail directly to admin if the error continues Admin-Mail: [email protected]";
type = "Error";
Status = true;
}
}
}
}
ViewBag.Message = message;
ViewBag.Status = Status;
ViewBag.Type = type;
return(View());
}
public async Task <ActionResult> ResetPassword(ResetPassword model)
{
if (ModelState.IsValid)
{
var meta = repo.GetPuckMeta().Where(x => x.Name == DBNames.PasswordResetToken && x.Key == model.ResetToken).FirstOrDefault();
if (meta == null)
{
ModelState.AddModelError("", "Password reset request not found.");
return(View(model));
}
var user = await userManager.FindByEmailAsync(meta.Value);
if (user == null)
{
ModelState.AddModelError("", "User not found.");
return(View(model));
}
var token = await userManager.GeneratePasswordResetTokenAsync(user);
var result = await userManager.ResetPasswordAsync(user, token, model.Password);
if (!result.Succeeded)
{
string message = string.Join(" ", result.Errors.Select(x => x.Description));
ModelState.AddModelError("", message);
return(View(model));
}
repo.DeleteMeta(meta);
repo.SaveChanges();
ViewBag.SuccessMessage = "Password successfully changed.";
return(View(model));
}
return(View(model));
}
public ActionResult ResetPassword(ResetPassword model)
{
if (!ConfigBase.Settings.PasswordReset)
{
return(HttpNotFound());
}
try
{
AntiForgery.Validate();
}
catch (Exception ex)
{
ex.Log();
return(null);
///TODO: Change the message
return(Json(new { status = "error", message = Words.Login_SessionExpired }));
}
if (!ModelState.IsValid)
{
return(null);
}
if (!ValidateEmail(model.EmailAddress))
{
return(Json(new { status = "error", message = Words.Login_PasswordResetInvalidEmail }));
}
if (new AuthLogin().ResetPassword(model.EmailAddress))
{
return(Json(new { status = "success", message = Words.Login_PasswordResetEmailSent }));
}
else
{
return(Json(new { status = "error", message = Words.Login_PasswordResetInvalidEmail }));
}
}
public void GivenAnonymousPostRequest_WithValidData_DeletesPasswordRetrieval()
{
var expectedObject = new PasswordRetrieval
{
Token = Guid.NewGuid(),
UserId = User.Id
};
Db.Save(expectedObject);
var model = new ResetPassword
{
Token = expectedObject.Token,
Password = "******" + GetRandom.String(10),
};
model.PasswordConfirm = model.Password;
var result = Controller.ResetPassword(model) as ViewResult;
result.Should().Not.Be.Null();
var previousObject = Db.SingleOrDefault<PasswordRetrieval>(new { expectedObject.Id });
previousObject.Should().Be.Null();
}
public ActionResult ResetPassword(ResetPassword model)
{
if (ModelState.IsValid)
{
using (RavenSession.GetCachingContext())
{
model.Data = RavenSession.Query<PasswordRetrieval>().SingleOrDefault(x => x.Token == model.Token);
if (model.Data == null)
return Redirect(Url.Home().Index());
User.UserObject.Password = model.Password.ToSHAHash();
RavenSession.Store(User.UserObject);
RavenSession.Delete(model.Data);
RavenSession.SaveChanges();
Metrics.Increment(Metric.Users_ResetPassword);
}
//show confirmation
return View("ResetPasswordConfirmation");
}
return View(model);
}
public void GivenAuthenticatedPostRequest_Redirects()
{
var model = new ResetPassword();
ControllerUtilities.SetupControllerContext(Controller, User);
var result = Controller.ResetPassword(model) as RedirectResult;
result.Should().Not.Be.Null();
result.Url.Should().Equal(Controller.Url.Home().Index());
var notification = Controller.TempData[ViewDataConstants.Notification] as Notification;
notification.Should().Not.Be.Null();
}
public void GivenAnonymousPostRequest_WithValidId_IncrementsMetric()
{
var expectedObject = new PasswordRetrieval
{
Token = Guid.NewGuid(),
UserId = User.Id
};
Db.Save(expectedObject);
var model = new ResetPassword
{
Token = expectedObject.Token,
Password = "******" + GetRandom.String(10),
};
model.PasswordConfirm = model.Password;
var result = Controller.ResetPassword(model) as ViewResult;
result.Should().Not.Be.Null();
MetricsMock.Verify(x => x.Increment(Metric.Users_ResetPassword), Times.Once());
}
public void GivenAnonymousPostRequest_WithValidData_UpdatesUserPassword()
{
var expectedObject = new PasswordRetrieval
{
Token = Guid.NewGuid(),
UserId = User.Id
};
Db.Save(expectedObject);
var model = new ResetPassword
{
Token = expectedObject.Token,
Password = "******" + GetRandom.String(10),
};
model.PasswordConfirm = model.Password;
Controller.ResetPassword(model);
var user = Db.SingleOrDefault<User>(new { User.Id });
user.Password.Should().Equal(model.PasswordConfirm.ToSHAHash());
}
public async Task<ActionResult> ResetPassword(ResetPassword formModel)
{
var userId = GetCookieValue(Request, StorefrontConstants.CustomerIdCookie);
var token = GetCookieValue(Request, StorefrontConstants.PasswordResetTokenCookie);
if (userId == null && token == null)
{
WorkContext.ErrorMessage = "Not enough info for reseting password";
return View("error", WorkContext);
}
var result = await _commerceCoreApi.StorefrontSecurityResetPasswordAsync(userId, token, formModel.Password);
if (result.Succeeded == true)
{
// Remove cookies
SetCookieValue(Response, StorefrontConstants.CustomerIdCookie);
SetCookieValue(Response, StorefrontConstants.PasswordResetTokenCookie);
return View("customers/reset_password_confirmation", WorkContext);
}
else
{
ModelState.AddModelError("form", result.Errors.First());
}
return View("customers/reset_password", WorkContext);
}
public ActionResult ResetPassword(ResetPassword model)
{
if (User.Identity.IsAuthenticated)
{
NotifyInfo("You are already logged in. Log out and try again.");
return Redirect(Url.Home().Index());
}
if (ModelState.IsValid)
{
model.Data = Db.SingleOrDefault<PasswordRetrieval>(new { model.Token });
if (model.Data == null)
{
NotifyWarning("Sorry! We couldn't verify that this user requested a password reset. Please try resetting again.");
return Redirect(Url.Account().ForgotPassword());
}
var user = Db.Query<User>("delete from [{0}] where Id=@resetId;update [{1}] set Password=@Password, ModifiedOn=GetUtcDate() where Id=@UserId;select * from [{1}] where Id=@UserId"
.Fmt(
Db.GetTableName<PasswordRetrieval>(),
Db.GetTableName<User>()
), new
{
ResetId = model.Data.Id,
Password = model.Password.ToSHAHash(),
model.Data.UserId
}).SingleOrDefault();
Cache.Trigger(TriggerFor.Id<User>(user.Id));
_authenticationService.SetLoginCookie(user, true);
Metrics.Increment(Metric.Users_ResetPassword);
//show confirmation
return View("ResetPasswordConfirmation");
}
return View(model);
}
public async Task<ActionResult> ResetPassword(ResetPassword formModel)
{
var customerIdCookie = HttpContext.Request.Cookies[StorefrontConstants.CustomerIdCookie];
string userId = customerIdCookie != null ? customerIdCookie.Value : null;
var tokenCookie = HttpContext.Request.Cookies[StorefrontConstants.PasswordResetTokenCookie];
string token = tokenCookie != null ? tokenCookie.Value : null;
if (userId == null && token == null)
{
WorkContext.ErrorMessage = "Not enough info for reseting password";
return View("error", WorkContext);
}
var result = await _commerceCoreApi.StorefrontSecurityResetPasswordAsync(userId, token, formModel.Password);
if (result.Succeeded == true)
{
HttpContext.Response.Cookies.Add(new HttpCookie(StorefrontConstants.CustomerIdCookie) { Expires = DateTime.UtcNow.AddDays(-1) });
HttpContext.Response.Cookies.Add(new HttpCookie(StorefrontConstants.PasswordResetTokenCookie) { Expires = DateTime.UtcNow.AddDays(-1) });
return View("customers/reset_password_confirmation", WorkContext);
}
else
{
ModelState.AddModelError("form", result.Errors.First());
}
return View("customers/reset_password", WorkContext);
}
public void UpdatePassword(ResetPassword command)
{
this.PasswordHash = command.PasswordHash;
this.UpdateAt = command.CreateAt;
this.UpdateBy = command.CreateBy;
}
public async Task<IHttpActionResult> ResetPassword(ResetPasswordVM vm)
{
var userSecurity = _userSecurityService.Get(vm.User);
if (!userSecurity.EnsoureState(UserSecurityCommand.ResetPassword))
{
return Conflict();
}
ResetPassword action = new ResetPassword(
userSecurity.UserId, DateTime.Now, userSecurity.UserId, _userSecurityService.PasswordHash(userSecurity.UserId, vm.Password), vm.Token);
ActionResponse actionResponse = await ActionBus.SendAsync<UserActionBase, ResetPassword>(action);
return Ok(ActionResponseVM.ToVM(actionResponse));
}
public ActionResult ResetPassword(string token)
{
if (User.Identity.IsAuthenticated)
{
NotifyInfo("You are already logged in. Log out and try again.");
return Redirect(Url.Home().Index());
}
Guid guidToken;
if (!Guid.TryParse(token, out guidToken))
{
NotifyWarning("Sorry! We couldn't verify that this user requested a password reset. Please try resetting again.");
return Redirect(Url.Account().ForgotPassword());
}
var model = new ResetPassword
{
Token = guidToken,
Data = Db.SingleOrDefault<PasswordRetrieval>(new { Token = guidToken })
};
if (model.Data == null)
{
NotifyWarning("Sorry! We couldn't verify that this user requested a password reset. Please try resetting again.");
return Redirect(Url.Account().ForgotPassword());
}
return View(model);
}
public void GivenAnonymousPostRequest_WithValidData_LogsInUser()
{
var expectedObject = new PasswordRetrieval
{
Token = Guid.NewGuid(),
UserId = User.Id
};
Db.Save(expectedObject);
var model = new ResetPassword
{
Token = expectedObject.Token,
Password = "******" + GetRandom.String(10),
};
model.PasswordConfirm = model.Password;
Controller.ResetPassword(model);
AuthenticationService.Verify(x => x.SetLoginCookie(It.Is<User>(u => u.Id == User.Id), true), Times.Once());
}
public void GivenAnonymousPostRequest_WithValidData_ReturnsView()
{
var expectedObject = new PasswordRetrieval
{
Token = Guid.NewGuid(),
UserId = User.Id
};
Db.Save(expectedObject);
var model = new ResetPassword
{
Token = expectedObject.Token,
Password = "******" + GetRandom.String(10),
};
model.PasswordConfirm = model.Password;
var result = Controller.ResetPassword(model) as ViewResult;
result.Should().Not.Be.Null();
result.ViewName.Should().Equal("ResetPasswordConfirmation");
}
public void ClearResetPasswordToken(ResetPassword command)
{
this.ResetPasswordToken = null;
this.UpdateAt = command.CreateAt;
this.UpdateBy = command.CreateBy;
}
public ActionResult ResetPassword(Guid token)
{
var model = new ResetPassword { Token = token };
using (RavenSession.GetCachingContext())
{
model.Data = RavenSession.Query<PasswordRetrieval>().SingleOrDefault(x => x.Token == token);
if (model.Data == null)
return Redirect(Url.Home().Index());
return View(model);
}
}
public ActionResult ForgotPassword(ForgotPasswordViewModelMyOwn model)
{
if (ModelState.IsValid)
{
ResetPassword RP = new ResetPassword();
UserModel UM = new UserModel();
UserManagerFK UMF = new UserManagerFK();
string email = UMF.GetUserEmail(model.UserName);
if (email == null)
{
return View("ForgotPasswordConfirmation");
}
Guid EMailCode = Guid.NewGuid();
var callbackUrl = Url.Action("ResetPassword", "UserAccount", new { userId = email, code = EMailCode }, protocol: Request.Url.Scheme);
UMF.AddResetPasswordDetails(EMailCode, email, "Y");
//SmtpClient SmtpClient = new SmtpClient("smtp.gmail.com");
//MailAddressCollection MailAddressCollection = new MailAddressCollection();
//MailMessage message = new MailMessage();
//message.From = new MailAddress("*****@*****.**", "Faheem Kathrada");
//message.Body = "Please reset your password by clicking < a href =\"" + callbackUrl + "\">here</a>";
//message.Subject = "Nexidia Log Files";
//message.To.Add("*****@*****.**");
//SmtpClient.Port = 587;
//SmtpClient.EnableSsl = true;
//SmtpClient.Send(message);
//message.Dispose();
var client = new SmtpClient("smtp.gmail.com", 587)
{
Credentials = new NetworkCredential("*****@*****.**", "8September@008"),
EnableSsl = true
};
client.Send("*****@*****.**", "*****@*****.**", "Password Reset", "Please reset your password by clicking < a href =\"" + callbackUrl + "\">here</a>");
return RedirectToAction("ForgotPasswordConfirmation", "Account");
}
return View(model);
}