public ActionResult RestorePasswordPartial(RestorePasswordModel m)
{
//check in db email and write token in db
//generate url to request RecoveryPassword
var operation = new RecoveryPasswordOperation(m.Email);
operation.ExcecuteTransaction();
if (operation.Success)
{
var user = operation._user;
try
{
SendMailAsync(user);
ViewBag.Success = true;
}
catch
{
ModelState.AddModelError("Email", "Ошибка при отправлении письма");
}
}
else
{
ErrorHelpers.AddModelErrors(ModelState, operation.Errors);
}
return(PartialView(m));
}
public virtual async Task <NetResult <ResponseData> > RestorePassword([FromBody] RestorePasswordModel model)
{
try
{
SuccessResult result = new SuccessResult();
if (string.IsNullOrEmpty(model.Token))
{
throw new CoreException("Token not found", 5);
}
var loginResult = await _user.RestorePassword(model);
if (loginResult.IsSentOtp)
{
SendSms(loginResult.UserName, model.Otp);
}
return(new ResponseData()
{
Result = loginResult
});
}
catch (Exception ext)
{
return(ext);
}
}
public async Task <bool> RestorePasswor(RestorePasswordModel model)
{
if (!model.IsCompare())
{
return(false);
}
var user = await GetByUserName(model.UserName);//GetFirst(m => m.UserName == model.UserName);
if (user == null)
{
throw new CoreException("User Not Valid", 5);
}
if (!string.IsNullOrEmpty(model.Token))
{
}
if (CheckUserOtp(user, model.Otp))
{
user.Password = RepositoryState.GetHashString(model.Password);
}
else
{
//4 Restore Password
throw new CoreException("Error Otp", 4);
}
await Update(user);
return(true);
}
public void RestorePasswordNonExisting()
{
var model = new RestorePasswordModel {
Username = "******", Email = "*****@*****.**"
};
this.tests.Storage.RestorePassword(model);
}
public User RestorePassword(RestorePasswordModel restorePasswordModel)
{
var user = this.storage.RestorePassword(restorePasswordModel);
this.cacheProvider.Invalidate("user-id-" + user.Id, "user-name-" + user.Username, "users");
return(user);
}
public void RestorePasswordNonExisting()
{
var model = new RestorePasswordModel {
Email = "*****@*****.**"
};
_Tests.Storage.RestorePassword(model);
}
public void RestorePasswordNonExistingTest()
{
var model = new RestorePasswordModel {
Username = "******", Email = "*****@*****.**"
};
// Trying to restore password of non existing user.
this.tests.Storage.RestorePassword(model);
}
internal static bool RestorePassword(RestorePasswordModel model)
{
var newpass = "";
if (!String.IsNullOrEmpty(newpass = dataAccess.RestorePassword(model)))
{
EmailSender.SendResetEmail(model.Email, model.UserName, newpass);
return(true);
}
return(false);
}
public User RestorePassword(RestorePasswordModel restorePasswordModel)
{
var db = this.GetDbContext();
var user = db.Users.SingleOrDefault(u => u.Username == restorePasswordModel.Username && u.Email == restorePasswordModel.Email);
var password = this.RandomPassword();
user.Password = this.EncryptPassword(password);
db.SubmitChanges();
this.SendEmail("admin@iudico", user.Email, "Iudico Notification", "Your password has been changed:" + password);
return(user);
}
public ActionResult RestorePassword(RestorePasswordModel model)
{
if (ModelState.IsValid)
{
if (Auction.RestorePassword(model))
{
return(RedirectToAction("EmailIsSent"));
}
}
ModelState.AddModelError("", "The username or email is incorrect.");
return(View(model));
}
/// <summary>
/// Отсылает пользователю новый сгенерированный пароль по Email,
/// если, конечно он зарегестрирован в системе
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ServiceResponce RestorePassword(RestorePasswordModel model)
{
IList <User> users = _userRep.FindAllByCredentails(model.Email, model.Phone);
if (users == null)
{
return(ServiceResponce
.FromFailed()
.Add("error", "user doesn't exist"));
}
/* if (users.Count > 1)
* {
* return ServiceResponce
* .FromFailed()
* .Add("error", "user doesn't exist");
* } */
User user = new User();
if (users.Count == 1)
{
foreach (User u in users)
{
user = u;
}
}
string Password = PasswordService.GeneratePasswordString();
user.Password = PasswordService.GeneratePasswordHash(Password);
_userRep.Save(user);
new Thread(send =>
{
RestorePasswordEmailModel RestorePasswordEmailModel = RestorePasswordEmailModelHelper.GetRestorePasswordEmailModel(user.UserName, Password);
string RestoreText = _templateServ
.Run("Emails/RestorePassword", typeof(RestorePasswordEmailModel), RestorePasswordEmailModel);
if (!EmailService.SendMail(RestorePasswordEmailModel, RestoreText))
{
user.UserStatuses.Description = "Restore password Email was not delivered";
user.UserStatuses.UpdateTime = DateTime.Now;
}
else
{
user.UserStatuses.Description = "Restore password Email was delivered at " + DateTime.Now;
user.UserStatuses.UpdateTime = DateTime.Now;
}
}).Start();
return(ServiceResponce.FromSuccess());
}
public void RestorePassword(RestorePasswordModel restorePasswordModel)
{
var db = GetDbContext();
var user = db.Users.Single(u => u.Email == restorePasswordModel.Email);
var password = RandomPassword();
user.Password = EncryptPassword(password);
db.SubmitChanges();
SendEmail("admin@iudico", user.Email, "Iudico Notification", "Your password has been changed:" + password);
}
public void RestorePasswordExisting()
{
var model = new RestorePasswordModel {
Email = "*****@*****.**"
};
var password = _Tests.DataContext.Users.Where(u => u.Username == "panza").Single().Password;
_Tests.Storage.RestorePassword(model);
var newpassword = _Tests.DataContext.Users.Where(u => u.Username == "panza").Single().Password;
Assert.IsTrue(newpassword != password);
}
public string RestorePassword(RestorePasswordModel model)
{
var result = "";
var etalon = _dataBase.Users.FirstOrDefault(u => u.Username == model.UserName);
if (etalon != null && etalon.Email == model.Email)
{
result = GenerateRandomPass();
etalon.Password = result;
_dataBase.SaveChanges();
}
return(result);
}
public void RestorePasswordSuccess()
{
var model = new RestorePasswordModel {
Email = "*****@*****.**"
};
var password = _Tests.DataContext.Users.Where(u => u.Username == "panza").Single().Password;
_Tests.Storage.RestorePassword(model);
_Tests.MockStorage.Verify(u => u.SendEmail(It.IsAny <string>(), It.Is <string>(s => s == "*****@*****.**"), It.IsAny <string>(), It.IsAny <string>()), Times.Once());
var newpassword = _Tests.DataContext.Users.Where(u => u.Username == "panza").Single().Password;
Assert.IsTrue(newpassword != password);
}
public void RestorePasswordExistingTest()
{
var model = new RestorePasswordModel {
Username = "******", Email = "*****@*****.**"
};
// Getting old password.
var password = this.tests.DataContext.Users.Single(u => u.Username == "panza").Password;
this.tests.Storage.RestorePassword(model);
// Getting new password.
var newpassword = this.tests.DataContext.Users.Single(u => u.Username == "panza").Password;
// Verifying if new and old passwords are not equal.
Assert.AreNotEqual(newpassword, password);
}
public async Task <ActionResult> Index(string username)
{
metricSender.SendCount("restore_password.try");
var users = await FindUsers(username);
var answer = new RestorePasswordModel
{
UserName = username
};
if (!users.Any())
{
answer.Messages.Add(new Message($"Пользователь {username} не найден"));
return(View(answer));
}
metricSender.SendCount("restore_password.found_users");
foreach (var user in users)
{
if (string.IsNullOrWhiteSpace(user.Email))
{
answer.Messages.Add(new Message($"У пользователя {user.UserName} не указана электронная почта"));
continue;
}
if (!user.EmailConfirmed)
{
answer.Messages.Add(new Message($"У пользователя {user.UserName} не подтверждена электронная почта"));
continue;
}
var requestId = await requestRepo.CreateRequest(user.Id);
if (requestId == null)
{
answer.Messages.Add(new Message($"Слишком частые запросы для пользователя {user.UserName}. Попробуйте ещё раз через несколько минут"));
continue;
}
await SendRestorePasswordEmail(requestId, user);
answer.Messages.Add(new Message($"Письмо с инструкцией по восстановлению пароля для пользователя {user.UserName} отправлено вам на почту", false));
}
return(View(answer));
}
public IHttpActionResult RestorePassword([FromBody] RestorePasswordModel model)
{
var member = Services.MemberService.GetByUsername(model.Username);
if (member == null)
{
return(NotValid());
}
var password = Membership.GeneratePassword(8, 2);
Services.MemberService.SavePassword(member, password);
string body;
using (var writer = new StringWriter())
{
var routeData = new RouteData();
routeData.Values.Add("controller", "Fake");
var fakeControllerContext = new ControllerContext(new HttpContextWrapper(new HttpContext(new HttpRequest(null, "https://iibb.by", null), new HttpResponse(null))), routeData, new FakeController());
var razorViewEngine = new RazorViewEngine();
var razorViewResult = razorViewEngine.FindView(fakeControllerContext, "EmailForgotPassword", "", false);
dynamic data = new ExpandoObject();
data.Name = member.Name;
data.Password = password;
var viewContext = new ViewContext(fakeControllerContext, razorViewResult.View, new ViewDataDictionary(data), new TempDataDictionary(), writer);
razorViewResult.View.Render(viewContext, writer);
body = writer.ToString();
}
var message = new MailMessage();
message.To.Add(new MailAddress(model.Username));
message.From = new MailAddress("*****@*****.**");
message.Subject = "Восстановление пароля Irene Italiano BOUTIQUE BIJOUTERIE";
message.Body = body;
message.IsBodyHtml = true;
using (var smtp = new SmtpClient())
{
smtp.Send(message);
}
return(Ok());
}
public async Task <IActionResult> ChangePassword([FromBody] RestorePasswordModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = await userManager.FindByNameAsync(User.Identity.Name);
var result = await userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(Ok(new { result = true }));
}
return(Ok(new { code = StatusMessage.ErrorChangePass, result = false }));
}
public ActionResult Forgot(RestorePasswordModel restorePasswordModel)
{
var user = this.storage.GetUser(u => u.Username == restorePasswordModel.Username && u.Email == restorePasswordModel.Email);
if (user == null)
{
this.ModelState.AddModelError("NotFound", "User with such username and email combination not found");
}
if (!this.ModelState.IsValid)
{
return(View(restorePasswordModel));
}
this.storage.RestorePassword(restorePasswordModel);
return(this.View("ForgotSent"));
}
public ActionResult Forgot(RestorePasswordModel restorePasswordModel)
{
var user = _Storage.GetUser(u => u.Email == restorePasswordModel.Email);
if (user == null)
{
ModelState.AddModelError("Email", "No user with such email");
}
if (!ModelState.IsValid)
{
return(View(restorePasswordModel));
}
_Storage.RestorePassword(restorePasswordModel);
return(View("ForgotSent"));
}
public ActionResult RestorePassword(RestorePasswordModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
using (var db = new ExchangedbEntities())
{
var id = Session["Id"].ToString();
Session.Abandon();
var dbUser = db.Users.FirstOrDefault(a => a.Id.ToString().Equals(id));
if (dbUser != null)
{
dbUser.Password = MD5Helper.GetHashString(model.NewPassword);
db.SaveChanges();
}
return(RedirectToAction("Login"));
}
}
/// <summary>
/// Restore password by telephone number.
/// </summary>
/// <param name="restorePasswordModel">Restore password model.</param>
/// <returns>
/// Connection token to server.
/// </returns>
/// <exception cref="System.ArgumentException">When one of params invalid.</exception>
/// <exception cref="System.ArgumentNullException">When user not found or not registraited.</exception>
/// <exception cref="System.InvalidOperationException">When validation code not the same.</exception>
public async Task <LoginToken> RestorePassword(RestorePasswordModel restorePasswordModel)
{
restorePasswordModel.CheckArgumentException();
if (!restorePasswordModel.ValidationCode.ValidateCode(restorePasswordModel.TelephoneNumber))
{
throw new InvalidOperationException();
}
var user = GetUserByTelephoneNumber(restorePasswordModel.TelephoneNumber)
?? throw new ArgumentNullException();
var password = GetUserPasswordByUserId(user.Id)
?? throw new ArgumentNullException();
password.Password = restorePasswordModel.Password.HashPassword();
var editedPassword = await _userPasswordRepository.EditAsync(password);
return(GetToken(user));
}
public async Task <ActionResult> Index(string username)
{
var users = await FindUsers(username);
var answer = new RestorePasswordModel
{
UserName = username
};
if (!users.Any())
{
answer.Messages.Add(new Message(string.Format("Пользователь {0} не найден", username)));
return(View(answer));
}
foreach (var user in users)
{
if (string.IsNullOrWhiteSpace(user.Email))
{
answer.Messages.Add(new Message(string.Format("У пользователя {0} не указан email", user.UserName)));
continue;
}
var requestId = await requestRepo.CreateRequest(user.Id);
if (requestId == null)
{
answer.Messages.Add(new Message(string.Format("Слишком частые запросы для пользователя {0}. Попробуйте ещё раз через несколько минут", user.UserName)));
continue;
}
await SendRestorePasswordEmail(requestId, user);
answer.Messages.Add(new Message(string.Format("Письмо с инструкцией по восстановлению пароля для пользователя {0} отправлено на Ваш email", user.UserName), false));
}
return(View(answer));
}
public User RestorePassword(RestorePasswordModel restorePasswordModel)
{
var user = this.storage.RestorePassword(restorePasswordModel);
this.cacheProvider.Invalidate("user-id-" + user.Id, "user-name-" + user.Username, "users");
return user;
}
// /api/session/RestorePassword
public async Task <LoginToken> RestorePassword([FromBody] RestorePasswordModel restorePasswordModel)
{
return(await _service.RestorePassword(restorePasswordModel));
}
public Task <LoginResult> RestorePassword(RestorePasswordModel model)
{
throw new NotImplementedException();
}
public User RestorePassword(RestorePasswordModel restorePasswordModel)
{
var db = this.GetDbContext();
var user = db.Users.SingleOrDefault(u => u.Username == restorePasswordModel.Username && u.Email == restorePasswordModel.Email);
var password = this.RandomPassword();
user.Password = this.EncryptPassword(password);
db.SubmitChanges();
this.SendEmail("admin@iudico", user.Email, "Iudico Notification", "Your password has been changed:" + password);
return user;
}
public void RestorePassword(RestorePasswordModel restorePasswordModel)
{
var db = GetDbContext();
var user = db.Users.Single(u => u.Email == restorePasswordModel.Email);
var password = RandomPassword();
user.Password = EncryptPassword(password);
db.SubmitChanges();
SendEmail("admin@iudico", user.Email, "Iudico Notification", "Your password has been changed:" + password);
}
public IHttpActionResult RestorePassword([FromBody] RestorePasswordModel model)
{
return(Ok(UserServ.RestorePassword(model).Response()));
}
