public ActionResult ConfirmarRedefinicaoSenha()
{
ResetPasswordModel pageModel = new ResetPasswordModel();
this.BindBasePageModel(pageModel);
pageModel.ResetPasswordData = new ResetPasswordData();
pageModel.ResetPasswordData.PasswordVerificationToken = Request.QueryString["token"];
return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/ConfirmarRedefinicaoSenha", pageModel);
}
public async void HttpPost_ResetPassword_ModelIsInvalid_ReturnsViewWithModel()
{
var passwordResetModel = new ResetPasswordModel();
var controller = AccountController();
controller.ModelState.AddModelError("Some model property", "Some error occurred");
var result = await controller.ResetPassword(A.Dummy<Guid>(), A.Dummy<string>(), passwordResetModel);
Assert.IsType<ViewResult>(result);
Assert.Equal(passwordResetModel, ((ViewResult)result).Model);
}
public ActionResult ConfirmarRedefinicaoSenhaPost(ResetPasswordModel model)
{
ResetPasswordModel pageModel = new ResetPasswordModel();
this.BindBasePageModel(pageModel);
try
{
customerAPIClient.ResetPasswordWithToken(new ResetPasswordData() { PasswordVerificationToken = model.ResetPasswordData.PasswordVerificationToken, NewPassword = model.ResetPasswordData.NewPassword });
}
catch (Exception ex)
{
ViewBag.Error = ex.Message;
return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/ConfirmarRedefinicaoSenha", pageModel);
}
ViewBag.Error = "Senha alterada com sucesso.";
ViewBag.Sucesso = "1";
return RedirectToAction("Index");
}
public async void HttpPost_ResetPassword_ModelIsValid_CallsApiToResetPassword()
{
var passwordResetModel = new ResetPasswordModel();
A.CallTo(() => unauthenticatedUserClient.ResetPasswordAsync(A<PasswordResetData>._))
.Returns(true);
A.CallTo(() => weeeAuthorization.SignIn(A<string>._, A<string>._, A<bool>._))
.Returns(LoginResult.Success("dshjkal", A.Dummy<ActionResult>()));
A.CallTo(() => apiClient.User)
.Returns(unauthenticatedUserClient);
await AccountController().ResetPassword(A.Dummy<Guid>(), A.Dummy<string>(), passwordResetModel);
A.CallTo(() => unauthenticatedUserClient.ResetPasswordAsync(A<PasswordResetData>._))
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task <IActionResult> ResetPassword(ResetPasswordModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(RedirectToAction("Home", "Index"));
}
var result = await _userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("Login", "Account"));
}
return(View(model));
}
public async Task <IHttpActionResult> ResetPassword(ResetPasswordModel model)
{
if (String.IsNullOrEmpty(model?.PasswordResetToken))
{
return(BadRequest("Invalid Password Reset Token."));
}
var user = await _userRepository.GetByPasswordResetTokenAsync(model.PasswordResetToken);
if (user == null)
{
return(BadRequest("Invalid Password Reset Token."));
}
if (!user.HasValidPasswordResetTokenExpiration())
{
return(BadRequest("Password Reset Token has expired."));
}
if (!IsValidPassword(model.Password))
{
return(BadRequest(_invalidPasswordMessage));
}
user.MarkEmailAddressVerified();
await ChangePassword(user, model.Password);
// TODO: use last logged in org
var organizationId = user.Memberships.Count > 0 ? user.Memberships.First().OrganizationId : null;
if (user.IsAdmin(organizationId))
{
await _organizationService.TryMarkOrganizationAsVerifiedAsync(organizationId);
}
ExceptionlessClient.Default.CreateFeatureUsage("Reset Password").AddObject(user).Submit();
return(Ok(new TokenResponseModel {
Token = await GetToken(user, organizationId)
}));
}
public ActionResult ResetPassword(string id)
{
try
{
var model = new ResetPasswordModel();
if (Request["result"] == "success")
{
return(View(model));
}
var RequestID = id;
if (RequestID == null)
{
return(RedirectToAction("ForgetPassword"));
}
string ConnectionString = WebConfigurationManager.ConnectionStrings["MainDB"].ConnectionString;
if (ConnectionString == null)
{
throw new Exception("Invalid Server Setting. Please contact IT support to update Web.config.");
}
var req = new Request();
using (var db = new Database(new SqlConnection(ConnectionString)))
{
db.Connection.Open();
req = db.FirstOrDefault <Request>("where RequestID = @RequestID", new { RequestID = RequestID });
db.Connection.Close();
}
model.UserPrincipalName = req.UserID;
model.RequestID = req.RequestID;
return(View(model));
}
catch (Exception ex)
{
ModelState.AddModelError("ActiveDirectory", ex.Message);
var model = new ResetPasswordModel();
return(View(model));
}
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordModel model)
{
var validateTokenResult = await ValidateToken(model.Token);
if (!validateTokenResult.IsValidToken)
{
_log.Warning($"Invalid token provided: {model.Token}");
return(BadRequest(ErrorResponse.Create("Invalid token")));
}
try
{
var employee = await _payInvoiceClient.GetEmployeeAsync(validateTokenResult.ResetPasswordToken.EmployeeId);
await _payAuthClient.UpdateAsync(new UpdateCredentialsModel
{
Email = employee.Email,
EmployeeId = employee.Id,
MerchantId = employee.MerchantId,
Password = model.Password
});
await _payAuthClient.RedeemResetPasswordTokenAsync(model.Token);
}
catch (Exception e)
{
_log.Error(e, $"Error occured for token: {model.Token}");
return(BadRequest(ErrorResponse.Create("Error occured")));
}
if (User.Identity.IsAuthenticated)
{
await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
}
_log.Info($"ResetPassword success for token {model.Token} by {HttpContext?.Connection?.RemoteIpAddress?.ToString().SanitizeIp()}");
return(Ok());
}
public async Task <IActionResult> ResetPassword(ResetPasswordModel resetPasswordModel)
{
const string _error = "Reset password has been failed!";
if (!Infrastructure.Extensions.TryFromBase64String(resetPasswordModel.ResetToken, out var resetTokenArray))
{
return(BadRequest(_error));
}
var unprotectedResetTokenArray = _dataProtector.Unprotect(resetTokenArray);
var userIdInput = string.Empty;
using (var ms = new MemoryStream(unprotectedResetTokenArray))
using (var reader = new BinaryReader(ms))
{
reader.ReadInt64();
userIdInput = reader.ReadString();
}
if (!Guid.TryParse(userIdInput, out var _))
{
return(BadRequest(_error));
}
var user = await _userManager.FindByIdAsync(userIdInput);
if (user == null)
{
return(BadRequest(_error));
}
var result = await _userManager.ResetPasswordAsync(user, resetPasswordModel.ResetToken, resetPasswordModel.Password);
if (!result.Succeeded)
{
return(BadRequest(_error));
}
return(Ok());
}
public async Task <object> ResetPassword([FromBody] ResetPasswordModel model)
{
if (!ModelState.IsValid)
{
return(new
{
success = false,
errors = GetModelState()
});
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(new
{
success = true
});
}
var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
if (result.Succeeded)
{
return(new
{
success = true
});
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(new
{
success = false,
errors = GetModelState()
});
}
public ActionResult ResetPassword(ResetPasswordModel model)
{
//validate model, set new password
if (ModelState.IsValid)
{
try
{
model.Code = Request.Params["prc"];
AccountService.ResetPassword(model);
return(RedirectToAction("Index", "Home", new { }));
}
catch (ReturnEmailNotFoundException ex)
{
return(RedirectToAction("InvalidUrl", "Content"));
}
}
else
{
return(View(model));
}
}
public ActionResult ResetPassword(ResetPasswordModel model)
{
string hashedPassword = null;
MembershipService service = new MembershipService();
ActionResult result = null;
if (ModelState.IsValid)
{
hashedPassword = service.EseguiHashPassword(model.Password);
UtenteRepository.Instance.AggiornaPassword(model.UtenteId, hashedPassword);
result = RedirectToAction("Index", "Home");
}
else
{
model.TokenValido = true;
result = View(model);
}
return(result);
}
public ActionResult ResetPassword(string token)
{
if (string.IsNullOrEmpty(token))
{
throw new HttpException((int)HttpStatusCode.NotFound, "not found");
}
ResetPasswordRequest request = _membershipService.GetActivePasswordResetRequestByToken(token);
if (request == null)
{
throw new HttpException((int)HttpStatusCode.NotFound, "not found");
}
ResetPasswordModel model = new ResetPasswordModel();
model.Init(_membershipService.MinPasswordLength);
model.Token = request.Token;
return(View(model));
}
// Reset Password
public bool ResetPassword(ResetPasswordModel resetPassword)
{
UserModel isUserExists = new UserModel();
try
{
isUserExists = CheckUserExists(resetPassword.email);
if (isUserExists != null)
{
isUserExists.password = resetPassword.password;
isUserExists.updatedAt = DateTime.Now;
_userRepository.Update(isUserExists);
return(true);
}
}
catch (Exception ex)
{
string msg = ex.Message;
}
return(false);
}
// 10.Reset Password
public ActionResult ResetPassword(string id)
{
// Verify the reset password link
// Find Account associated with this link
// Redirect to reset password page
using (UserDBContext db = new UserDBContext())
{
var user = db.Users.Where(x => x.ResetPasswordCode == id).FirstOrDefault();
if (user != null)
{
ResetPasswordModel model = new ResetPasswordModel();
model.ResetCode = id;
return(View(model));
}
else
{
return(HttpNotFound());
}
}
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordModel model)
{
#region Validate Model
var userInputValidated = _resetPasswordValidator.Validate(model);
if (!userInputValidated.IsValid)
{
_infos.Add(_badRequest.ShowError(int.Parse(userInputValidated.Errors[0].ErrorMessage)).Message);
return(BadRequest(new CustomResponse <string> {
Message = _infos
}));
}
#endregion
var resetPassword = await _user.ResetPassword(model);
return(Ok(resetPassword));
}
public ActionResult ResetPassword(ResetPasswordModel resetPasswordModel)
{
if (ModelState.IsValid)
{
//TODO: userId ignored as we only allow users to reset their own passwords
MembershipUser currentUser = Membership.GetUser(resetPasswordModel.Username);
if (currentUser != null)
{
currentUser.UnlockUser();
string newPassword = currentUser.ResetPassword();
SendPasswordResetEmail(currentUser.Email, newPassword);
TempData["isSuccessReset"] = true;
return(RedirectToAction("Logon"));
}
else
{
ModelState.AddModelError("Username", "Username not found.");
}
}
return(View(resetPasswordModel));
}
public ActionResult ResetPassword(ResetPasswordModel model)
{
if (ModelState.IsValid)
{
using (ELearningDB db = new ELearningDB())
{
var user = db.TaiKhoans.Find(model.ID);
if (model.AuthenticationCode != user.NguoiDung.MaXacNhan)
{
ViewBag.ResetPass = "******";
return(View(model));
}
user.Password = Encryptor.MD5Hash(model.Password);
user.NguoiDung.MaXacNhan = null;
db.SaveChanges();
TempData["ResetPass"] = "******";
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public async Task <User> ResetPassword(ResetPasswordModel model)
{
User dbUser = await GetUserById(model.UserId);
if (dbUser.ResetPasswordToken != model.Token || DateTimeOffset.UtcNow >= dbUser.ResetPasswordExpirationDate)
{
throw new Exception("This reset password token is invalid or has expired. Please try again later.");
}
string salt = Helpers.CreateUniqueString(64);
dbUser.UpdatedDate = DateTimeOffset.Now;
dbUser.ResetPasswordToken = null;
dbUser.ResetPasswordExpirationDate = null;
dbUser.Salt = salt;
dbUser.PasswordHash = model.Password.Encrypt(salt);
await Context.SaveChangesAsync();
return(dbUser);
}
public ActionResult ResetPassword(ResetPasswordModel model)
{
if (ModelState.IsValid)
{
using (var db = new BonoboGitServerContext())
{
var user = db.Users.FirstOrDefault(x => x.Username.Equals(model.Username, StringComparison.OrdinalIgnoreCase));
if (user == null)
{
TempData["ResetSuccess"] = false;
Response.AppendToLog("FAILURE");
}
else
{
MembershipService.UpdateUser(model.Username, user.Name, user.Surname, user.Email, model.Password);
TempData["ResetSuccess"] = true;
}
}
}
return(View(model));
}
//verify the reset Passworrd link
public ActionResult ResetPassword(string resetPassCode)
{
//verify the reset pass link
//find account associated with that link
//redirect to reset password page
using (LoginContext context = new LoginContext())
{
var user = context.Users.Where(u => u.ResetPasswordCode == resetPassCode).FirstOrDefault();
if (user != null)
{
ResetPasswordModel resetModel = new ResetPasswordModel();
resetModel.ResetCode = resetPassCode;
return(View(resetModel));
}
else
{
return(HttpNotFound());
}
}
}
public ActionResult ResetPassword(string id)
{
//Verify the reset password link
//Find account associated with this link
//redirect to reset password page
using (MyDatabaseEntities dc = new MyDatabaseEntities())
{
var user = dc.Users.Where(a => a.ResetPasswordCode == id).FirstOrDefault();
if (user != null)
{
ResetPasswordModel model = new ResetPasswordModel();
model.ResetCode = id;
return(View(model));
}
else
{
return(HttpNotFound());
}
}
}
internal async Task <HttpResponseMessage> ResetPassword(ResetPasswordModel resetPassword)
{
var url = $"{_Config.Value.Okta_OrgUri}/api/v1/users/{resetPassword.UserId}";
var postValue = new
{
credentials = new
{
password = new
{
value = resetPassword.Password
}
}
};
var data = new ByteArrayContent(System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(postValue)));
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Add("Accept", "application/json");
client.DefaultRequestHeaders.Add("Authorization", "SSWS " + _Config.Value.Okta_APIToken);
data.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(await client.PutAsync(url, data));
}
public ActionResult ResetPassword(string id)
{
//varify reset password link
//rediecrt to reset password page
//find account accociadted with the link
//check the uniquecode from db
using (SurveyEntities db = new SurveyEntities())
{
var user = db.Users.Where(a => a.ResetPassword == id).FirstOrDefault(); //find the account associated with this id
if (user != null) //id is reset password code and we match it with the db reset pass code and if found user associated with this id
{
ResetPasswordModel mod = new ResetPasswordModel();
mod.ResetCode = id; //so valide id when submit rest password form
return(View(mod)); // here code for the user can see the rset password view
}
else
{
return(HttpNotFound());// error for invalid link
}
}
}
public async Task <IActionResult> ResetPassword(ResetPasswordModel resetPasswordModel)
{
var token = await this.accountBL.ResetPassword(resetPasswordModel);
string message = string.Empty;
bool success = false;
if (token)
{
success = true;
message = "Password changed successfully ";
return(this.Ok(new { success, message }));
}
else
{
success = false;
message = "Password Reset Failed";
return(this.BadRequest(new { success, message }));
}
}
public ActionResult SubmitResetPassword(ResetPasswordModel model)
{
var data = new ActionOutput();
if (model.UserId > 0 && model.type == (int)UserTypes.User)
{
var result = _userManager.ChangePassword(model);
if (result.Status == ActionStatus.Successfull)
{
data.Message = "Password reset successfully"; data.Status = ActionStatus.Successfull;
}
else
{
data.Message = "Error occured"; data.Status = ActionStatus.Error;
}
return(Json(data, JsonRequestBehavior.AllowGet));
}
data.Message = "Unexpected error";
data.Status = ActionStatus.Error;
return(Json(data, JsonRequestBehavior.AllowGet));
}
public ActionResult ResetPassword(string Token)
{
tblUser userModel = _dbRepository.GetEntities().FirstOrDefault(m => m.Token == Token);
if (userModel.UserId > 0 && userModel.TokenExpiryDateTime >= DateTime.Now)
{
ResetPasswordModel model = new ResetPasswordModel {
UserId = userModel.UserId
};
return(View(model));
}
if (userModel.TokenExpiryDateTime < DateTime.Now)
{
TempData[Enums.NotifyType.Error.GetDescription()] = "Token for reset password has been expired.please try again to reset password.";
return(View("Index"));
}
TempData[Enums.NotifyType.Error.GetDescription()] = "Something Went wrong. Please try again later.";
return(View("Index"));
}
public async Task <IActionResult> ResetPassword(ResetPasswordModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var response = await _accountsEndpoint.ResetPassword(model);
if (response.Succeeded)
{
return(View("ResetPasswordConfirmation"));
}
//TODO Does this not leave us security vulnerable. i.e. Email/User exists?
foreach (var error in response.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(model));
}
public async Task <IActionResult> ResetPassword(ResetPasswordModel 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 <OperationResult> ResetPassword(ResetPasswordModel model)
{
if (!ModelState.IsValid)
{
var allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new OperationResult(false, string.Join(" ", allErrors)));
}
var user = await UserManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(new OperationResult(false));
}
var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
if (result.Succeeded)
{
return(new OperationResult(true));
}
return(new OperationResult(false, string.Join(" ", result)));
}
public async Task <IActionResult> ResetPasswordAsync([FromBody] ResetPasswordModel model)
{
var user = await _userService.FindOneAsync(new UserFilter
{
ResetPasswordToken = model.Token,
AsNoTracking = true
},
x => new User
{
Id = x.Id
});
if (user == null)
{
return(BadRequest(nameof(model.Token), "Password reset link has expired or invalid."));
}
await _userService.UpdatePasswordAsync(user.Id, model.Password);
return(Ok());
}
public bool ResetPassword(int id, ResetPasswordModel reset)
{
ResetPasswordModel password = new ResetPasswordModel
{
NewPassword = reset.NewPassword,
ConfirmPassword = reset.ConfirmPassword,
};
if (password.NewPassword == password.ConfirmPassword)
{
var dbUser = userContext.Users.FirstOrDefault(s => s.UserId == id);
dbUser.Password = reset.NewPassword;
userContext.SaveChanges();
return(true);
}
else
{
return(false);
}
}
public async Task <IActionResult> ResetPassword(ResetPasswordModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(RedirectToAction(nameof(ResetPasswordConfirmation)));
}
var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
if (result.Succeeded)
{
return(RedirectToAction(nameof(ResetPasswordConfirmation)));
}
AddErrors(result);
return(View());
}
public ActionResult ResetPassword(string id)
{
//Verify the Resetcode
//Find Account associate with the Link
//Redirect to reset Password Page
using (DataBaseContext db = new DataBaseContext())
{
var user = db.Users.Where(a => a.ResetPasswordCode == id).FirstOrDefault();
if (user != null)
{
ResetPasswordModel model = new ResetPasswordModel();
model.ResetCode = id;
return(View(model));
}
else
{
return(HttpNotFound());
}
}
}
public virtual ActionResult ResetPasswordRespond(ResetPasswordModel model)
{
if (
ModelState.IsValid &&
AccountService.ResetPassword(model.Email, model.ResetCode, model.NewPassword)
) {
// UserEventLogService.LogUserEvent(UserActions.ResetPassword);
return RedirectToAction(Actions.LogIn());
} else {
ModelState.AddModelError("", SystemErrors.PasswordResetFailed);
ViewData["PasswordLength"] = AccountService.MinPasswordLength;
model.NavigationLocation = new string[] { "Home", "ResetPassword" };
this.FeedbackError("There was an error processing your password reset request...");
return View(model);
}
}
public ActionResult ResetPassword(ResetPasswordModel model)
{
if (!string.IsNullOrEmpty(model.Email))
{
// L'utilisateur existe ?
var user = this.db.Users.FirstOrDefault(entry => entry.UserName == model.Email);
if (user == null)
{
ModelState.AddModelError(string.Empty, "Votre email n'existe pas.");
}
else
{
var confirmationToken = this.GeneratePasswordResetToken(model.Email);
if (string.IsNullOrEmpty(confirmationToken))
{
ModelState.AddModelError(string.Empty, "Votre email n'existe pas.");
}
else
{
this.SendEmailReset(model.Email, confirmationToken);
return this.RedirectToAction("ResetPasswordStepTwo");
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Email invalide.");
}
// Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire
return this.View(model);
}
public HttpResponseMessage ResetPassword(ResetPasswordModel model)
{
ActionOutput Result = _homeManager.ResetPassword(model);
return Request.CreateResponse<ApiActionOutput>(HttpStatusCode.OK, new ApiActionOutput
{
Status = Result.Status,
Message = Result.Message
});
}
public async Task<HttpResponseMessage> ResetPassword(ResetPasswordModel model)
{
List<string> errors = new List<string>();
if (!ModelState.IsValid)
{
errors.AddRange(ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToList());
return Request.CreateResponse(HttpStatusCode.BadRequest, errors);
}
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
errors.Add("Don't reveal that the user does not exist");
return Request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray());
}
var result = await UserManager.ChangePasswordAsync(user.Id, model.SentPassword, model.NewPassword);
if (result.Succeeded)
{
return Request.CreateResponse(HttpStatusCode.OK, user);
}
errors.Add("An error has occured while changing password.");
return Request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray());
}
public ActionResult RedefinirSenhaPost(ResetPasswordModel model)
{
ResetPasswordModel pageModel = new ResetPasswordModel();
this.BindBasePageModel(pageModel);
try
{
customerAPIClient.GeneratePasswordReset(new ResetPasswordData() { Email = model.ResetPasswordData.Email });
}
catch (Exception ex)
{
ViewBag.Error = ex.Message;
return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/RedefinirSenha", pageModel);
}
ViewBag.Error = "Siga as instruções no seu email.";
ViewBag.Sucesso = "1";
return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/RedefinirSenha", pageModel);
//return RedirectToAction("Index");
}
public async Task<ActionResult> ResetPassword(Guid id, string token, ResetPasswordModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
using (var client = apiClient())
{
var passwordResetData = new PasswordResetData
{
Password = model.Password,
Token = token,
UserId = id
};
try
{
bool result = await client.User.ResetPasswordAsync(passwordResetData);
return View(!result ? "ResetPasswordExpired" : "ResetPasswordComplete");
}
catch (ApiBadRequestException ex)
{
this.HandleBadRequest(ex);
if (ModelState.IsValid)
{
throw;
}
AddRemoveModelStateErrors();
}
return View(model);
}
}
ActionOutput IHomeManager.ResetPassword(ResetPasswordModel model)
{
int[] regvia = { (int)RegisterVia.Android, (int)RegisterVia.Website, (int)RegisterVia.IPhone };
User user = Context.Users.Where(m => m.Email == model.UserEmail).FirstOrDefault();
if (user == null)
return new ActionOutput
{
Message = "User does not exists.",
Status = ActionStatus.Error
};
if (!user.ResetPassword)
return new ActionOutput
{
Message = "User doesn't requested to reset the password.",
Status = ActionStatus.Error
};
if (user.PasswordResetCode != model.ResetCode)
return new ActionOutput
{
Message = "Password reset code does not match.",
Status = ActionStatus.Error
};
if (!regvia.Contains(user.RegisterVia))
return new ActionOutput
{
Message = "Password can not be reset for facebook user.",
Status = ActionStatus.Error
};
user.ResetPassword = false;
user.PasswordResetCode = null;
user.Password = Utility.GetEncryptedValue(model.NewPassword);
SaveChanges();
return new ActionOutput
{
Message = "Password has been reset.",
Status = ActionStatus.Successfull
};
}
public async Task<ActionResult> ResetPassword(Guid id, string token, ResetPasswordModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
using (var client = apiClient())
{
var passwordResetData = new PasswordResetData
{
Password = model.Password,
Token = token,
UserId = id
};
try
{
bool result = await client.User.ResetPasswordAsync(passwordResetData);
return View(!result ? "ResetPasswordExpired" : "ResetPasswordComplete");
}
catch (ApiBadRequestException ex)
{
this.HandleBadRequest(ex);
if (ModelState.IsValid)
{
throw;
}
foreach (var modelState in ViewData.ModelState.Values.ToList())
{
List<int> errorsToRemoveIndex = new List<int>();
for (var i = modelState.Errors.Count - 1; i >= 0; i--)
{
if (modelState.Errors[i].ErrorMessage.Contains("Passwords") && modelState.Value == null)
{
errorsToRemoveIndex.Add(i);
}
}
foreach (int index in errorsToRemoveIndex)
{
modelState.Errors.RemoveAt(index);
}
}
}
return View(model);
}
}
public ActionResult ResetPassword(ResetPasswordModelWebsite model)
{
ResetPasswordModel reset = new ResetPasswordModel { NewPassword = model.Password, ResetCode = model.ResetCode, UserEmail = model.UserEmail };
return Json(_homeManager.ResetPassword(reset), JsonRequestBehavior.AllowGet);
}
public async void HttpPost_ResetPassword_ModelIsValid_PasswordResetThrowsApiBadRequestExceptionWithModelErrors_ReturnsViewWithModel_AndErrorAddedToModelState()
{
// Arrange
Dictionary<string, ICollection<string>> modelState = new Dictionary<string, ICollection<string>>
{
{
"A Key", new List<string>
{
"Something wen't wrong"
}
}
};
ApiBadRequestException badRequestException = new ApiBadRequestException(HttpStatusCode.BadRequest, new ApiBadRequest
{
ModelState = modelState
});
IUnauthenticatedUser unauthenticatedUserClient = A.Fake<IUnauthenticatedUser>();
A.CallTo(() => unauthenticatedUserClient.ResetPasswordAsync(A<PasswordResetData>._))
.Throws(badRequestException);
A.CallTo(() => apiClient.User)
.Returns(unauthenticatedUserClient);
AccountController controller = AccountController();
ResetPasswordModel passwordResetModel = new ResetPasswordModel();
// Act
ActionResult result = await controller.ResetPassword(A.Dummy<Guid>(), A.Dummy<string>(), passwordResetModel);
// Assert
Assert.IsType<ViewResult>(result);
Assert.Equal(passwordResetModel, ((ViewResult)result).Model);
Assert.Single(controller.ModelState.Values);
Assert.Single(controller.ModelState.Values.Single().Errors);
Assert.Contains("Something wen't wrong", controller.ModelState.Values.Single().Errors.Single().ErrorMessage);
}
public ActionResult ResetPassword(ResetPasswordModel model)
{
var errorMessage = String.Empty;
if (!ModelState.IsValid)
{
return View(model);
}
// Try sending reset
try
{
var question = WebSecurity.GetSecretQuestion(model.Email);
}
catch (MembershipPasswordException e)
{
errorMessage = e.Message;
}
if (String.IsNullOrEmpty(errorMessage))
{
var success = WebSecurity.SendResetPassword(Request.Url.Host, model.Email, model.Answer);
if (success)
{
return RedirectToAction("ResetPasswordSuccess");
}
ModelState.AddModelError("", "The answer did not match our records");
return View(model);
}
ModelState.AddModelError("", errorMessage);
return View(model);
}
public virtual ActionResult ResetPassword(ResetPasswordModel model)
{
if (ModelState.IsValid) {
model.ResetCode = model.Email.PasswordHashString();
//Send email
string link = String.Format(@"visit our <a href='{0}/Account/ResetPasswordRespond/{1}?rc={2}'>Password Reset page</a>",
SystemConfig.BaseUrl,
model.Email,
model.ResetCode);
string msg = String.Format(SystemMessages.PasswordResetRequestLink, link);
Mail.SendMail(
String.Format("{0} <{1}>", SiteProfileData.SiteProfile().CompanyName, SystemConfig.AdminEmailAddress),//
model.Email,
SystemMessages.PasswordResetRequestSubjectLine,
String.Format("{0} {1}", String.Format(SystemMessages.PasswordResetRequest, SiteProfileData.SiteProfile().CompanyName), msg)
);
return RedirectToAction(Actions.ResetPasswordSuccess());
}
ViewData["PasswordLength"] = AccountService.MinPasswordLength;
model.NavigationLocation = new string[] { "Account", "ResetPassword" };
this.FeedbackError("There was an error processing your password reset request...");
return View(model);
}
// **************************************
// URL: /Account/ResetPasswordRespond
// **************************************
public virtual ActionResult ResetPasswordRespond(string id, string rc)
{
var model = new ResetPasswordModel() {
Email = id,
ResetCode = rc
};
ViewData["PasswordLength"] = AccountService.MinPasswordLength;
model.NavigationLocation = new string[] { "Account", "ResetPassword" };
return View(model);
}
public ActionResult RedefinirSenha()
{
ResetPasswordModel pageModel = new ResetPasswordModel();
this.BindBasePageModel(pageModel);
pageModel.ResetPasswordData = new ResetPasswordData();
return View("../CustomCode/VICommerce/" + EcommerceContext.AccountDomain + "/RedefinirSenha", pageModel);
}
public ActionResult ForgetPassword(ResetPasswordModel model)
{
if (ModelState.IsValid)
{
User user = _securityService.GetUsers().Where(x => x.Email == model.UserEmail).FirstOrDefault();
if (user != null)
{
if (_securityService.ForgetPassword(user))
{
//return RedirectToAction("Login", "Account");
const string returnStr = @"<div class='message-info'>Please, check you email for reset password.</div>";
return Content(returnStr);
}
else
{
return Content("Sorry, we could not find anyone with that email address!");
}
}
else
{
return Content("You are not valid user!");
}
}
else
{
return Content("Please review your form!");
}
}
