public async Task <ResultModel> ResetPassword([FromBody] PasswordResetModel model)
{
var ret = new ResultModel {
IsSucceeded = true
};
if (model.Password != model.ConfirmPassword)
{
ret.IsSucceeded = false;
ret.ErrorMessage = "两次输入的密码不一致";
return(ret);
}
var user = await _userManager.FindByNameAsync(model.UserName);
if (user == null)
{
ret.IsSucceeded = false;
ret.ErrorMessage = "密码重置失败";
return(ret);
}
var result = await _userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (!result.Succeeded)
{
ret.IsSucceeded = false;
ret.ErrorMessage = result.Errors.Any() ? result.Errors.Select(i => i.Description).Aggregate((accu, next) => accu + "\n" + next) : "注册失败";
}
return(ret);
}
public ActionResult ResetPassword(PasswordResetModel passwordResetModel)
{
if (ModelState.IsValid)
{
var client = new RestClient(WebConfigurationManager.AppSettings["webApiUrl"]);
var request = new RestRequest("api/account/resetpassword", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddJsonBody(passwordResetModel);
var response = client.Execute(request);
if (response.StatusCode == HttpStatusCode.OK)
{
return(View("~/Views/Account/PasswordSuccessfullyReset.cshtml"));
}
else
{
return(RedirectToAction("ResetPassword",
new { email = passwordResetModel.Email, token = passwordResetModel.Token }));
}
}
return(RedirectToAction("ResetPassword",
new { email = passwordResetModel.Email, token = passwordResetModel.Token }));
}
public static void MailUserPasswordResetRequest(PasswordResetModel passwordResetModel, UserModel userModel)
{
try
{
string mailServer = ConfigurationManager.AppSettings["mailServer"];
string from = ConfigurationManager.AppSettings["fromAddress"];
string body = ConfigurationManager.AppSettings["passwordResetBody"];
string subject = ConfigurationManager.AppSettings["passwordResetSubject"];
string resetUrl = ConfigurationManager.AppSettings["passwordResetUrl"];
string url = "<a href='" + string.Format(resetUrl, passwordResetModel.PasswordResetKey) + "'>here</a>";
MailMessage mailMessage = new MailMessage();
mailMessage.IsBodyHtml = true;
mailMessage.From = new MailAddress(from);
mailMessage.To.Add(new MailAddress(userModel.Email));
mailMessage.Subject = subject;
mailMessage.Body = string.Format(body, url);
SmtpClient client = new SmtpClient();
client.Send(mailMessage);
}
catch (Exception ex)
{
Logger.CreateLog("Email failed for message to " + userModel.Email + " exception is " + ex, 1);
}
}
public async Task <ActionResult> ResetPassword(PasswordResetModel model)
{
var result = await _userAccountManager.ResetPassword(model);
if (result.Success)
{
return(RedirectToAction("PasswordResetSuccessful"));
}
TempData.SetErrorMessage(result.Message);
if (PasswordResetStatus.BadPassword == result.ResetStatus)
{
return(View(
new PasswordResetViewModel
{
Marker = model.Marker,
Email = model.Email
}));
}
if (PasswordResetStatus.RequestExpired == result.ResetStatus)
{
return(RedirectToAction("ForgotPassword"));
}
//Must be bad username.
return(RedirectToAction("ForgotPassword", "Account"));
}
public ActionResult PasswordReset(PasswordResetModel model)
{
if (ModelState.IsValid)
{
// Check if the student exists.
var student = StudentRepository.GetByEmail(model.Email);
if (student != null)
{
// Generate a password for the student and hash it.
string password = PasswordGenerator.CreateRandomPassword();
student.Password = Crypto.HashPassword(password);
StudentRepository.Update(student);
// Create a mail message with the password and mail it to the student.
var msg = new EmailMessage
{
text = string.Format("Beste {1},{0}Er is een aavraag gedaan om je wachtwoord te resetten.{0}Inlognaam: {3} {0}Wachtwoord: {2}{0}{0}",
Environment.NewLine,
student.FirstName,
password,
student.Email),
subject = "Studenten Volg Systeem wachtwoord reset",
to = new List <EmailAddress>
{
new EmailAddress(student.Email, string.Format("{0} {1}", student.FirstName, student.LastName)),
new EmailAddress(student.SchoolEmail, string.Format("{0} {1}", student.FirstName, student.LastName), "cc"),
},
};
_mailEngine.Send(msg);
}
}
model.Success = true;
return(View(model));
}
public async Task <ActionResult> ActivateAccount(PasswordResetModel model)
{
var result = await _userAccountManager.ResetPassword(model);
if (result.Success)
{
TempData[PasswordResetCompleteMessageKey] = "Account Activated";
return(RedirectToAction("PasswordResetSuccessful"));
}
TempData.SetErrorMessage(result.Message);
if (PasswordResetStatus.BadPassword == result.ResetStatus)
{
return(View(
new PasswordResetViewModel
{
Marker = model.Marker,
Email = model.Email
}));
}
if (PasswordResetStatus.RequestExpired == result.ResetStatus)
{
return(RedirectToAction("ResendAccountActivation"));
}
//Must be bad username.
return(RedirectToAction("ResendAccountActivation"));
}
public ActionResult ResetPass(PasswordResetModel pr, string id)
{
if (Session["important"] != null || Session["juststaff"] != null)
{
int count = 0;
if (ModelState.IsValid)
{
count = dao.UpdateStaffPassword(pr, id);
if (count > 0)
{
return(RedirectToAction("Index", "Staff"));
}
else
{
ViewBag.mid = id;
ViewBag.Message = "Error! " + dao.message;
}
ModelState.Clear();
return(View());
}
else
{
ViewBag.mid = id;
return(View());
}
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public ActionResult PasswordReset(PasswordResetModel model)
{
if (ModelState.IsValid)
{
var result = _applicationUserManager.ResetPasswordAsync(model.UserId, model.ResetToken, model.NewPassword).Result;
if (result.Succeeded)
{
Session["SuccessEvent"] = "Password reset was successful.";
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
return(View(model));
}
return(RedirectToAction("logon"));
}
return(View(model));
}
public IHttpActionResult ResetPassword(PasswordResetModel model)
{
try
{
string pass = "";
var user = _userService.GetUsers(x => x.Email == model.Email).FirstOrDefault();
if (user == null)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NotFound, "Email does not exist.")));
}
pass = user.Password;
if (model.Password != model.ConfirmPassword)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NotFound, "Password and confirm password does not match.")));
}
user.Password = PasswordHasher.CreateTextString(PasswordHasher.HashPassword(model.Password, SHA256Managed.Create()));
_userService.UpdateUser(user);
return(Ok());
}
catch (Exception ex)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message)));
}
}
public async Task <PasswordResetResult> ResetPassword(PasswordResetModel model)
{
try
{
var validationResult = await ValidateResetModel(model);
if (validationResult != null)
{
return(validationResult);
}
var user = await _identityProvider.FindUserByEmail(model.Email);
if (user == null)
{
return(PasswordResetResult.BadUsername);
}
var resetSuccessful = await _identityProvider.ResetUserPassword(user.UserName, model.Password);
if (!resetSuccessful)
{
return(PasswordResetResult.BadPassword);
}
return(PasswordResetResult.Successful);
}
catch (Exception e)
{
_log.Error("ResetPassword", e);
return(DatabaseUnreachableResult <PasswordResetResult>());
}
}
public ActionResult ForgotPassword(PasswordResetModel model)
{
string username;
string token;
p1p.Business.UserRepository uRepo = new Business.UserRepository();
if (uRepo.IsEmailRegistered(model.Email))
{
username = uRepo.GetUsernameByEmail(model.Email);
//TODO maybe should check for null but not being an anal overdefensive coder today
token = WebSecurity.GeneratePasswordResetToken(username);
MailMessage message = new MailMessage();
message.From = new MailAddress("*****@*****.**");
message.To.Add(new MailAddress(model.Email));
message.Subject = "LinkTracker Reset Password";
message.Body = "Follow this link to reset your password: http://" + HttpContext.Request.UrlReferrer.Authority + "/Account/ResetConfirmation?pt=" + token;
SmtpClient client = new SmtpClient();
client.Send(message);
return(RedirectToLocal("/Account/EmailSent"));
}
else
{
ModelState.AddModelError("", "Email not found.");
return(View(model));
}
}
public ActionResult PasswordReset(PasswordResetModel passwordReset)
{
using (db = new StateScholarshipEntities())
{
string id = Session["userid"].ToString();
if (id != null)
{
if (passwordReset.NewPassword != null && passwordReset.ConfirmPassword != null)
{
int userid = int.Parse(Session["userid"].ToString());
var UserIdCheck = db.Registration1.Where(d => d.User_id == userid).FirstOrDefault();
UserIdCheck.user_password = passwordReset.NewPassword;
db.SaveChanges();
ViewBag.SuccessMessage = "Password Updated successful";
}
else
{
ViewBag.Message = "Please enter Details";
}
}
else
{
return(RedirectToAction("Login"));
}
return(View());
}
}
public async Task <IActionResult> ResetPassword(PasswordResetModel model)
{
string decoded = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(model.Code));
AppUser user = await userManager.FindByEmailAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(Unauthorized());
}
IdentityResult result = await userManager.ResetPasswordAsync(user, decoded, model.Password);
if (result.Succeeded)
{
return(Ok());
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(BadRequest(ModelState));
}
public async Task <IHttpActionResult> PasswordReset(PasswordResetModel pwd)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityUser idUser = null;
using (Db.Operations ops = new Db.Operations())
{
idUser = await ops.FindUserByEmail(pwd.Email);
if (idUser != null)
{
IdentityResult result = await ops.ResetPasswordAsync(idUser.Id, pwd.Token, pwd.Password);
if (!result.Succeeded)
{
if (result.Errors != null && result.Errors.Count() > 0)
{
return(Redirect(pwd.FailUrl + "?error=" + GetErrorString(result)));
}
}
else
{
return(Redirect(pwd.SuccessUrl));
}
}
}
return(Ok());
}
public ActionResult ResetPass(string ids)
{
string[] idArr = ids.Split(',');
//idArr.Each(id => AppManager.Instance.UserManager.Remove(id.ToStr()));
string msg = "";
int i = 0;
foreach (var userSub in idArr)
{
if (string.IsNullOrEmpty(userSub))
{
continue;
}
PasswordResetModel model = new PasswordResetModel()
{
UserName = userSub, Password = "******", IsResetPass = 1
};
LoginState resState = AppManager.Instance.StateProvider.ResetPassword(model);
if (LoginState.OK != resState)
{
msg = msg + userSub + " ";
i++;
}
}
if (i == 0)
{
return(JsonTipsLang("success", null, "F_Reset_Password_Success"));
}
return(JsonTips("error", null, FStr.ResetPasswordFailed0, (object)null, msg));
}
public async Task <ActionResult> PasswordReset(PasswordResetModel model)
{
if (ModelState.IsValid)
{
//Получает пользователя из бд
var user = await UserManager.FindByNameAsync(model.Login);
if (user == null)
{
ModelState.AddModelError("", $"Пользователь {model.Login} не найден");
return(View(model));
}
//Создает токен смены пароля
var code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
//Создает ссылку для сброса пароля
var callbackUrl = Url.Action("ChangePassword", "Account", new { userId = user.Id, code = code },
protocol: Request.Url.Scheme);
//Отправляет письмо для сброса пароля
await UserManager.SendEmailAsync(user.Id, "Сброс пароля",
"Для сброса пароля перейдите по ссылке: <a href=\""
+ callbackUrl + "\">сбросить пароль</a>");
ViewBag.Message = "На вашу почту отправленно письмо для сброса пароля";
return(View("Confirm"));
}
return(View(model));
}
public virtual LoginState ResetPassword(PasswordResetModel model)
{
var _context = new ModelContext();
// var user = _context.UserProfiles.Find(2);
MemberShip member = _context.Set <MemberShip>().FirstOrDefault(m => m.UserName.Equals(model.UserName, StringComparison.OrdinalIgnoreCase));
if (member == null)
{
return(LoginState.UserNotExist);
}
if (model.Password != model.ConfirmPassword && model.IsResetPass != 1)
{
return(LoginState.PasswordError);
}
if (model.ConfirmToken != member.ConfirmationToken && model.IsResetPass != 1)
{
return(LoginState.TokenError);
}
member.PasswordSalt = CommOp.NewId();
member.Password = Encryption.MD5(model.Password + member.PasswordSalt);
member.PasswordChangedDate = DateTime.Now;
//对于系统重置的密码,强制吧修改密码日期移除让用户登陆重新修改面貌
if (model.IsResetPass == 1)
{
member.PasswordChangedDate = null;
}
_context.SaveChanges();
return(LoginState.OK);
}
public ActionResult PasswordReset(PasswordResetModel resetPassModel)
{
var customer = _repo.Customers.GetSingle(WebSecurity.CurrentUserId);
ViewBag.FirstName = customer.FirstName;
ViewBag.MiddleName = customer.MiddleName;
ViewBag.LastName = customer.LastName;
if ((resetPassModel == null) || (resetPassModel.OldPassword == "") || (resetPassModel.NewPassword == "") || (resetPassModel.ConfirmPassword == ""))
{
return(View(new PasswordResetModel()));
}
else if (!ModelState.IsValid)
{
return(View(resetPassModel));
}
else if (customer.Passoword != resetPassModel.OldPassword)
{
ModelState.AddModelError("", "Неправильный пароль(");
return(View(resetPassModel));
}
else if (resetPassModel.NewPassword != resetPassModel.ConfirmPassword)
{
ModelState.AddModelError("", "Не совпадают новый и подтвержденный пароль!");
return(View(resetPassModel));
}
else
{
customer.Passoword = resetPassModel.NewPassword;
_repo.SaveChanges();
return(View("PasswordResetted"));
}
return(View(resetPassModel));
}
public async Task <JObject> PasswordReset(PasswordResetModel model)
{
if (model.Password.Equals(model.NewPassword))
{
ModelState.AddModelError("Password", Message.OldPasswordEqualNew);
}
if (!ModelState.IsValid)
{
return(ExtJs.WriterJObject(false, errors: ExtJs.ModelStateToJObject(ModelState)));
}
var userId = User.Identity.GetUserId <int>();
var result = await UserManager.ChangePasswordAsync(userId, model.Password, model.NewPassword);
if (result.Succeeded)
{
SignInManager.AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
return(ExtJs.WriterJObject(true));
}
else
{
return(ExtJs.WriterJObject(false, errors: new JObject()
{
{ "Password", string.Join("<br/>", result.Errors) }
}));
}
}
public async Task <IActionResult> ResetPassword(PasswordResetModel model)
{
//var code = await userManager.GenerateEmailConfirmationTokenAsync();
var user = new ApplicationUser()
{
UserName = "******", Email = "*****@*****.**", IsEnabled = true, EmailConfirmed = true, FirstName = "Akinsanya", LastName = "Olanrewaju"
};
var result = await userManager.CreateAsync(user, "akinlanre@01");
if (roleManager.Roles.Count() == 0)
{
await roleManager.CreateAsync(new IdentityRole { Name = "Admin" });
await roleManager.CreateAsync(new IdentityRole { Name = "Client" });
await roleManager.CreateAsync(new IdentityRole { Name = "Inventory" });
}
//var u = await userManager.FindByNameAsync("admin");
var user1 = await userManager.FindByNameAsync("atplerry");
await userManager.AddToRolesAsync(user1, new string[] { "Admin", "Client", "Inventory" });
return(Content("Success", "text/html"));
}
public async Task<ActionResult> ResetPassword(PasswordResetModel accountUM)
{
try
{
if (!ModelState.IsValid) { return BadRequest(); }
MyUser user = await _userManager.FindByIdAsync(accountUM.Id);
if (user != null)
{
var result = await _userManager.ResetPasswordAsync(user, await _userManager.GeneratePasswordResetTokenAsync(user), accountUM.NewPassword);
if (result.Succeeded)
{
return Ok();
}
else
{
return BadRequest(result.Errors);
}
}
else
{
return NotFound();
}
}
catch (Exception e)
{
return BadRequest(e.Message);
}
}
public async Task <IActionResult> PasswordReset(PasswordResetModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByIdAsync(model.userId);
if (user == null)
{
return(RedirectToAction("Login", "Panel"));
}
var result = await _userManager.ResetPasswordAsync(user, model.token, model.password);
if (result.Succeeded)
{
TempData.Put("message", new AlertMessage()
{
Message = "Şifreniz Değiştirildi! Giriş Yapabilirsiniz.", AlertType = "success"
});
return(Redirect("/panel/login"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
public async Task <IdentityResult> ResetPassword(PasswordResetModel resetModel)
{
var user = await _userManager.FindByEmailAsync(resetModel.Email);
var result = await _userManager.ResetPasswordAsync(user, resetModel.Token, resetModel.Password);
return(result);
}
public void UmbracoUserControlTestSetup()
{
passWordResetModel = new PasswordResetModel();
passWordResetModelOut = new PasswordResetModel();
umbracoUserModel = new UmbracoUserModel();
umbracoUserModelListOut = new List <UmbracoUserModel>();
findUserModel = new FindUserModel();
contentTreeViewModel = new ContentTreeViewModel();
contentTreeViewModelListOut = new List <ContentTreeViewModel>();
permissionsModel = new PermissionsModel();
permissionsModelsListOut = new List <PermissionsModel>();
mockPermissionsControlService = new Mock <IPermissionsControlService>().Object;
mockEmailService = new Mock <IEmailService>().Object;
var userControlServiceMock = new Mock <IUserControlService>();
userControlServiceMock.Setup(x => x.LookupUserById(2))
.Returns(contentTreeViewModel);
mockUserControlService = userControlServiceMock.Object;
var umbracoServiceMock = new Mock <IUmbracoService>();
umbracoServiceMock.Setup(x => x.GetAllUsersByEmail("Email"))
.Returns(umbracoUserModelListOut);
umbracoServiceMock.Setup(x => x.GetAllUsersByUsername("Username"))
.Returns(umbracoUserModelListOut);
umbracoServiceMock.Setup(x => x.GetContentRoot())
.Returns(contentTreeViewModelListOut);
umbracoServiceMock.Setup(x => x.GetContentChild(1))
.Returns(contentTreeViewModelListOut);
umbracoServiceMock.Setup(x => x.SetContentPermissions(permissionsModel))
.Returns(true);
mockUmbracoService = umbracoServiceMock.Object;
var databaseServiceMock = new Mock <IDatabaseService>();
databaseServiceMock.Setup(x => x.GetResetDetails(passWordResetModel))
.Returns(passWordResetModelOut);
//databaseServiceMock.Setup(x => x.CheckUserPermissions(1))
// .Returns(permissionsModelsListOut);
mockDatabaseService = databaseServiceMock.Object;
timelimit = DateTime.Now;
//umbracoService = new UmbracoService();
//databaseService = new DatabaseService();
//emailService = new EmailService(mockDatabaseService);
//userControlService = new UserControlService(mockDatabaseService, mockUmbracoService, mockEmailService);
//permissionsControlService = new PermissionsControlService(mockDatabaseService, mockUmbracoService, mockUserControlService);
}
private async void ChangePassword_Button_Clicked(object sender, EventArgs e)
{
PasswordResetModel passwordResetModel = new PasswordResetModel();
passwordResetModel.Password = txt_Password.Text;
passwordResetModel.ConfirmPassword = txt_ConfirmPassword.Text;
passwordResetModel.ActivationCode = Activation_Code;
await(this.BindingContext as UsersViewModel).ResetPasswordAsync(passwordResetModel);
}
public ActionResult ResetSLXPassword(string userCode, string userId, int daysLeft)
{
PasswordResetModel model = new PasswordResetModel();
model.UserCode = userCode;
model.UserId = userId;
model.DaysLeft = daysLeft;
return(View(model));
}
public async Task<ActionResult> PasswordReset(PasswordResetModel model)
{
var identityModel = await _userManager.ResetPasswordAsync(model.UserId, model.Token, model.Password);
if (!identityModel.Succeeded)
{
return View("Error");
}
return RedirectToAction("Index", "Home");
}
public ActionResult ResetPassword(PasswordResetModel model)
{
if (ModelState.IsValid == false)
{
return(CurrentUmbracoPage());
}
var member = VerifyResetData(model);
if (member == null)
{
ModelState.AddModelError("", "Can't reset your password with the provided information");
return(CurrentUmbracoPage());
}
var queryString = new NameValueCollection();
try
{
var memberShip = Membership.GetUser(model.Email);
if (memberShip != null)
{
var memberService = ApplicationContext.Current.Services.MemberService;
// We need to unlock first else we are not allowed to do ResetPassword
member.IsLockedOut = false;
member.FailedPasswordAttempts = 0;
memberService.Save(member);
// Need to do this silly little dance, generate a new password first and
// then use it to reset the users password with the one they gave us.
// This is because allowManuallyChangingPassword="******"
var newPassword = memberShip.ResetPassword();
memberShip.ChangePassword(newPassword, model.NewPassword);
// Reset the token and expiry fields so that the password reset
// can not be repeated by using the same reset link
member.SetValue("passwordResetToken", string.Empty);
member.SetValue("passwordResetTokenExpiryDate", string.Empty);
memberService.Save(member);
queryString.Add("success", "true");
}
else
{
LogHelper.Warn <ResetPasswordController>($"ResetPassword - Can't find member in the MemberShip Provider {model.Email}");
ModelState.AddModelError("", "Can't reset your password with the provided information");
return(CurrentUmbracoPage());
}
}
catch (Exception ex)
{
LogHelper.Error <ResetPasswordController>("Couldn't reset password", ex);
}
return(RedirectToCurrentUmbracoPage(queryString));
}
public ActionResult ResetPassword(string request)
{
var model = new PasswordResetModel()
{
PasswordResetString = request
};
return(View(model));
}
public ActionResult PasswordReset(PasswordResetModel model)
{
var newPassword = EncriptacionMD5.Encriptar(model.Password);
var user = _readOnlyRepository.GetById <Account>(model.UserId);
user.Password = newPassword;
_writeOnlyRepository.Update <Account>(user);
return(RedirectToAction("LogIn", "Account"));
}
