public ActionResult ResetPass(ResetModel model)
{
if (model.Password != model.ConfirmPassword)
{
ModelState.AddModelError("", "Passwords do not match!");
return(View());
}
else
{
var provider = new DpapiDataProtectionProvider("MVC_Prices2");
userManager.UserTokenProvider = new DataProtectorTokenProvider <AppUser>(
provider.Create("MVC_Prices2"));
var result = userManager.ResetPasswordAsync(model.UserId, model.Code, model.Password);
if (result.Result.Succeeded)
{
return(RedirectToAction("Login"));
}
else
{
string valMessage = "";
foreach (var el in result.Result.Errors)
{
valMessage += el + " ";
}
ModelState.AddModelError("", valMessage);
return(View());
}
}
}
public async Task <IActionResult> Reset(ResetModel model)
{
if (ModelState.IsValid)
{
var user = _pool.GetUser(model.Email);
if (user != null)
{
await user.ConfirmForgotPasswordAsync(model.Code, model.Password);
RedirectToAction("Index", "Home");
// if (result.Succeeded)
// {
// }
// else
// {
// foreach (var item in result.Errors)
// {
// ModelState.AddModelError(item.Code, item.Description);
// }
// }
}
}
return(View(model));
}
public async Task <IActionResult> Reset([FromBody] ResetModel model)
{
if (!this.IsTokenValid(_tokenService.GetTemporaryToken(this.GetCurrentUserId())))
{
return(Unauthorized());
}
if (string.IsNullOrEmpty(model.NewPassword) || string.IsNullOrEmpty(model.ConfirmPassword) ||
model.NewPassword != model.ConfirmPassword)
{
return(BadRequest());
}
var result = await _mediator.Send(new ResetPasswordCommand
{
NgoId = NgoId,
UserId = this.GetCurrentUserId(),
NewPassword = model.NewPassword,
ConfirmPassword = model.ConfirmPassword
});
if (result == false)
{
return(NotFound());
}
return(Ok(new { message = "Parola a fost schimbata cu succes, puteti folosi aplicatia." }));
}
public IActionResult ResetPassword(ResetModel model)
{
if (ModelState.IsValid)
{
AppUser user = _userManager.FindByEmailAsync(model.Email).Result;
if (user != null)
{
string passwordResetToken = _userManager.GeneratePasswordResetTokenAsync(user).Result;
string passwordResetLink = Url.Action("ResetPasswordConfirm", "Account", new
{
userId = user.Id,
token = passwordResetToken
}, HttpContext.Request.Scheme);
/*
* string html = $"<form action='/confirm' enctype='multipart/form - data' method='post'><input type='hidden' name='Id' value='{user.Id}'/><input type='hidden' name='Token' value='{passwordResetToken}'/><button type='submit'>Tıklayınız</button></form>";
*/
string url = $"<h2>Şifrenizi yenilemek için lütfen aşağıdaki linke tıklayınız.</h2><hr/><a href='{passwordResetLink}'>şifre yenileme linki</a>";
Helper.PasswordReset.PasswordResetSendEmail(user.Email, "www.hergunbirmakale.com::Şifre sıfırlama", url);
ViewBag.status = "success";
}
else
{
ModelState.AddModelError("", "Sistemde kayıtlı email adresi bulunamamıştır");
}
}
return(View(model));
}
public ActionResult Reset(ResetModel resetModel)
{
if (ModelState.IsValid)
{
WebSecurity.ResetPassword(WebSecurity.GeneratePasswordResetToken(resetModel.UserName), resetModel.Password);
EmailModel emailmodel = new EmailModel();
emailmodel.To = resetModel.UserName;
emailmodel.Subject = "Reset Password";
StringBuilder sb = new StringBuilder();
sb.Append("<div style=\"padding:20px; font:normal 14px Arial, Helvetica, sans-serif; color:#333333;\">");
sb.Append("Hi User,<br />");
sb.Append("Your password has been changed.<br />");
sb.Append("regards,<br /> Funfooding Team");
emailmodel.EmailBody = sb.ToString();
Common.sendeMail(emailmodel, true);
//return RedirectToAction("Login", "Account");
if (WebSecurity.Login(resetModel.UserName, resetModel.Password, persistCookie: true))
{
var user = db.UserProfiles.Where(x => x.UserName.Equals(resetModel.UserName)).First();
int UserID = user.UserId;
Session["FirstName"] = user.FirstName;
return(RedirectPage(UserID));
}
}
return(View(resetModel));
}
public async Task ResetPasswordAsync([FromBody] ResetModel model)
{
if (TryValidateModel(model))
{
var user = await userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return;
}
var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (!result.Succeeded)
{
throw result.Errors.Any() ?
new BadRequestException(result.Errors.Select(i => i.Description).Aggregate((accu, next) => accu + "\n" + next))
: new BadRequestException();
}
}
else
{
var errors = ModelState.SelectMany(i => i.Value.Errors, (i, j) => j.ErrorMessage).ToList();
throw errors.Any() ?
new BadRequestException(errors.Aggregate((accu, next) => accu + "\n" + next))
: new BadRequestException();
}
}
public async Task <IActionResult> Reset(ResetModel model)
{
if (ModelState.IsValid)
{
var checkUser = await _userManager.FindByIdAsync(model.Guid);
if (checkUser == null)
{
ModelState.AddModelError(string.Empty, "User not exists!");
return(View(model));
}
if (model.Password != model.ConfirmPassword)
{
ModelState.AddModelError(string.Empty, "Password don't match!");
return(View(model));
}
var success = await _userManager.ChangePasswordAsync(checkUser, model.CurrentPassword, model.Password);
if (success.Succeeded)
{
return(RedirectToAction("Login", "Account", new { reset = true }));
}
foreach (var identityError in success.Errors)
{
ModelState.AddModelError(identityError.Code, identityError.Description);
}
return(View(model));
}
return(View(model));
}
public ActionResult Reset(string emailId)
{
ResetModel resetModel = new ResetModel();
resetModel.UserName = emailId;
return(View(resetModel));
}
public void UISaveResetModel(ResetModel resetModel)
{
User user = CurrentUser;
user.BindingEmail = new Email();
user.Password = resetModel.UpdatePassword;
userRepository.UserSaveChanges(user);
}
public async Task <IActionResult> Reset(string guid)
{
ResetModel model = new ResetModel {
Guid = guid, Password = "", ConfirmPassword = ""
};
return(View(model));
}
public ActionResult PasswordReset(string token)
{
ViewBag.isPasswordReset = false;
ResetModel reset = new ResetModel();
reset.token = token;
return(View(reset));
}
public IActionResult ResetPassword(string token, string email)
{
var model = new ResetModel {
Token = token, Email = email
};
return(View(model));
}
public async Task <IActionResult> BeginReset([FromBody] ResetModel model)
{
if (String.IsNullOrEmpty(model.ReturnUrl))
{
model.ReturnUrl = Request.Headers["Referer"].ToString();
}
await _adminAuthenticationProvider.BeginResetAsync(model.EmailAddress, HttpContext.Connection.RemoteIpAddress.ToString(), model.ReturnUrl);
return(Ok());
}
public ActionResult ResetCh(ResetModel model)
{
if (ModelState.IsValid)
{
ResetModel mdl = new ResetModel();
mdl.errorMessage = ResetChar(model.name);
TempData["r_model"] = mdl;
}
return(RedirectToAction("Index"));
}
public ActionResult Reset(string emailId)
{
ResetModel resetModel = new ResetModel();
emailId = emailId.Replace(" ", "+");
string DecryptMail = Common.Decrypt(emailId);
//resetModel.UserName = emailId;
resetModel.UserName = DecryptMail;
return(View(resetModel));
}
public ActionResult Reset()
{
var model = new ResetModel();
if (User.Identity.IsAuthenticated)
{
model.Email = User.Identity.GetUserEmail();
}
return(View(model));
}
public ActionResult Reset(string username = null)
{
var model = new ResetModel();
if (!string.IsNullOrWhiteSpace(username))
{
model.UserName = username;
}
return(View());
}
public ResetModel GetUserCaptcha(string captcha)
{
user = userRepository.FindUserCaptcha(captcha);
ResetModel resetModel = new ResetModel();
if (user.Email.Expire == null)
{
return(null);
}
resetModel.Captcha = user.Email.Captcha;
return(resetModel);
}
public ActionResult ResetPassword(ResetModel model)
{
if (ModelState.IsValid)
{
var user = db.Users
.FirstOrDefault(u => u.email == model.email);
if (user == null)
{
ModelState.AddModelError("", _("lblInvalidMailErr"));
}
else
{
try
{
var fromAddress = new MailAddress(Settings.Default.SMTP_Mail, Settings.Default.SMTP_FromName);
var toAddress = new MailAddress(model.email, user.firstName);
string fromPassword = Settings.Default.SMTP_Password;
string subject = Language.ResetPasword_SubjectMsg;
var passwordHelper = new PasswordHelper();
var password = GlobalHelpers.CreateRandomPassword(10);
passwordHelper.HashGeneratedPassword(password);
user.password = PWDTK.HashBytesToHexString(passwordHelper.Hash);
user.salt = PWDTK.HashBytesToHexString(passwordHelper.Salt);
db.SaveChanges();
string body = string.Format(
Language.ResetPassword_BodyMsg, user.CompleteName,
user.username, password
);
var smtp = new SmtpClient
{
Host = Settings.Default.SMTP_Host,
Port = Convert.ToInt16(Settings.Default.SMTP_Port),
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
UseDefaultCredentials = false,
Credentials = new NetworkCredential(fromAddress.Address, fromPassword)
};
using (var message = new MailMessage(fromAddress, toAddress) { Subject = subject, Body = body, IsBodyHtml = true })
{ smtp.Send(message); }
TempData["success"] = _("lblSendMailSuccess");
}
catch
{
ModelState.AddModelError("", _("lblSendMailErr"));
}
}
}
return View(model);
}
public ActionResult Reset(ResetModel model)
{
string message;
// Email address must be specified.
if (!string.IsNullOrWhiteSpace(model.Email))
{
// Get all accounts with that email address; check if there are any.
var accounts = new LinqMetaData().User.Where(u => u.EmailAddress == model.Email);
if (accounts.Any())
{
// Have some accounts. Filter out all but the unrestricted ones.
accounts = GetUnrestictedOnly(accounts, model.UserName, out message);
if (accounts.Any())
{
// Have unrestricted accounts. They will be reset. Assume there's
// more than one. If more than one, we don't necessarily know the
// person's name.
string firstName = null;
string lastName = null;
if (accounts.Count() == 1)
{
// Only one. So get person's name.
var account = accounts.First();
firstName = account.FirstName;
lastName = account.LastName;
}
// Create restriction on each account, send email and tell user it's done.
var key = CreateRestriction(accounts, model.Email, firstName != null);
SendResetEmail(model.Email, key, firstName, lastName);
return(RedirectToAction("ResetSuccess"));
}
}
else
{
// No accounts with the specified email address. Tell user.
message = Account.Invalid_EmailNotMatched;
}
}
else
{
// No email address. Tell user to enter one.
message = Account.Invalid_EmailNotSpecified;
}
ModelState.AddModelError("", message);
// If we got this far, something failed, redisplay form.
return(View());
}
public ActionResult ResetPassword(string Id)
{
if (Id == null || Id == string.Empty)
{
return(NotFound());
}
ResetModel reset = new ResetModel
{
Id = Id
};
return(View(reset));
}
public ResetModel ResetPassword(ResetModel model)
{
var URL = string.Format(AppSettings.BaseApiUrl + ApiUrls.Users.ResetPassword);
var Content = PostToken <ResetModel>(URL, model);
if (Content.IsSuccessful)
{
return(Content.Model);
}
else
{
return(new ResetModel());
}
}
public ActionResult Reset(ResetModel model)
{
if (ModelState.IsValid)
{
try
{
SmtpClient ss = new SmtpClient("smtp.gmail.com", 587);
ss.EnableSsl = true;
ss.Timeout = 10000;
ss.DeliveryMethod = SmtpDeliveryMethod.Network;
ss.UseDefaultCredentials = false;
ss.Credentials = new System.Net.NetworkCredential("*****@*****.**", "01012014");
// add from,to mailaddresses
MailAddress from = new MailAddress("*****@*****.**", "Administrator");
MailAddress to = new MailAddress(model.UserName, model.UserName);
MailMessage myMail = new System.Net.Mail.MailMessage(from, to);
// set subject and encoding
myMail.Subject = "Reset your password";
myMail.SubjectEncoding = System.Text.Encoding.UTF8;
// set body-message and encoding
myMail.Body = "<b>Test Mail</b><br>using <b>HTML</b>. <p>Please click on the following link to reset your password:</p> http://localhost:29330/Account/Register";
myMail.BodyEncoding = System.Text.Encoding.UTF8;
// text or html
myMail.IsBodyHtml = true;
ss.Send(myMail);
myMail.DeliveryNotificationOptions = DeliveryNotificationOptions.OnFailure;
ModelState.AddModelError("", "An email has been sent.");
TempData["success"] = "Your Balance is now zero";
}
catch (SmtpException ex)
{
throw new ApplicationException
("SmtpException has occured: " + ex.Message);
}
catch (Exception ex)
{
ModelState.AddModelError("", "The format of the email that you have provided is incorrect.");
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Reset(ResetModel model)
{
ResetModel RepoModel = _passwordService.GetResteModel();
if (!ModelState.IsValid)
{
return(View(model));
}
RepoModel.UpdatePassword = model.UpdatePassword.MD5Encrypt();
_passwordService.UISaveResetModel(RepoModel);
CookieHelper.RemoveCookie();
CookieHelper.AddCookie((int)RepoModel.Id, model.UpdatePassword);
return(View());
}
public IActionResult Email(ResetModel model, string submit)
{
if (submit == "send")
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
}
ViewBag.email = false;
CodeModel modelCodeTemp = new CodeModel();
modelCodeTemp.code = GetCode(5);
return(View("Index", modelCodeTemp));
}
public ActionResult PasswordReset(ResetModel model)
{
bool result = WebSecurity.ResetPassword(model.token, model.Password);
if (result == true)
{
ViewBag.isPasswordReset = true;
}
else
{
ViewBag.isPasswordReset = false;
ModelState.AddModelError(String.Empty, "The Reset token has expired.");
}
return(View());
}
public async Task <IActionResult> Reset([FromBody] ResetModel model)
{
if (string.IsNullOrEmpty(model.Action) || string.IsNullOrEmpty(model.PhoneNumber))
{
return(BadRequest());
}
if (string.Equals(model.Action, ControllerExtensions.DEVICE_RESET))
{
var result = await _mediator.Send(new ResetDeviceCommand
{
IdNgo = NgoId,
PhoneNumber = model.PhoneNumber,
Organizer = this.GetOrganizatorOrDefault(false)
});
if (result == -1)
{
return(NotFound(ControllerExtensions.RESET_ERROR_MESSAGE + model.PhoneNumber));
}
else
{
return(Ok(result));
}
}
if (string.Equals(model.Action, ControllerExtensions.PASSWORD_RESET))
{
var result = await _mediator.Send(new ResetPasswordCommand
{
IdNgo = NgoId,
PhoneNumber = model.PhoneNumber,
Pin = model.Pin,
Organizer = this.GetOrganizatorOrDefault(false)
});
if (result == false)
{
return(NotFound(ControllerExtensions.RESET_ERROR_MESSAGE + model.PhoneNumber));
}
return(Ok());
}
return(UnprocessableEntity());
}
public async Task <IActionResult> Reset([FromBody] ResetModel resetModel)
{
if (resetModel.username != User.Identity?.Name)
{
return(Forbid());
}
var user = await db.Users.FirstOrDefaultAsync(u => u.Login == resetModel.username);
if (user == null)
{
return(BadRequest(new { error = "Некорректные логин и/или пароль" }));
}
var salt = user.Salt;
var hashedPassword = Convert.ToBase64String(KeyDerivation.Pbkdf2(
password: resetModel.old_password,
salt: salt.ToByteArray(),
prf: KeyDerivationPrf.HMACSHA1,
iterationCount: 10000,
numBytesRequested: 256 / 8));
var loggedUser = await db.Users.Include(u => u.Role)
.FirstOrDefaultAsync(u => u.Login == resetModel.username && u.Password == hashedPassword);
if (loggedUser == null)
{
return(BadRequest(new { error = "Некорректные логин и/или пароль" }));
}
var newSalt = Guid.NewGuid();
var newHashedPassword = Convert.ToBase64String(KeyDerivation.Pbkdf2(
password: resetModel.new_password,
salt: newSalt.ToByteArray(),
prf: KeyDerivationPrf.HMACSHA1,
iterationCount: 10000,
numBytesRequested: 256 / 8));
loggedUser.Salt = newSalt;
loggedUser.Password = newHashedPassword;
await db.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> Reset(ResetModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(BadRequest("Incorrect"));
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
var result = await _userManager.ResetPasswordAsync(user, token, model.Password);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public ActionResult Reset(string captcha)
{
string chptcha = HttpContext.Request.QueryString[Keys.email].ToString();
ResetModel resetModel = new ResetModel();
resetModel = passwordService.GetUserCaptcha(chptcha);
if (resetModel == null)
{
ModelState.AddModelError(resetModel.Captcha, "验证时间过期");
return(View());
}
if (captcha != resetModel.Captcha)
{
ModelState.AddModelError(resetModel.Captcha, "验证密码不对，请填写正确的验证码");
return(View());
}
return(View());
}
