public async Task <ActionResult> NewPassword(NewPasswordViewModel mod)
{
if (ModelState.IsValid)
{
// string Password = EncryptDecrypt.Encrypt(System.Configuration.ConfigurationManager.AppSettings["EncryptID"], mod.NewPassword.Trim(), true);
string uri = ApiPath + "User/NewPassword";//http://localhost:5014/
CustomResponse user = new CustomResponse();
using (HttpClient httpClient = new HttpClient())
{
NewPasswordModel bmod = AutoMapper.Mapper.Map <NewPasswordModel>(mod);
var xx = await httpClient.PostAsJsonAsync(uri, bmod);
user = xx.Content.ReadAsAsync <CustomResponse>().Result;
}
return(RedirectToAction("login", "home"));
}
else
{
ModelState.AddModelError("", "Please fill Password and Confirm Password field.");
return(View());
}
}
public async Task <IActionResult> ResetPassword(NewPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(RedirectToAction("ForgotPasswordConfirmation", "Account", new { confirmationText = "Nie odnaleziono użytkownika" }));
}
var result = await UserManager.ResetPasswordAsync(user, model.Token, model.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(View());
}
return(RedirectToAction("ForgotPasswordConfirmation", "Account", new { confirmationText = "Hasło zostało pomyślnie zmienione" }));
}
public IActionResult EditPassword(NewPasswordViewModel newPasswordViewModel)
{
User user = this.dataService.GetObjectByPropertyValue <User>("UserId", newPasswordViewModel.UserId);
PasswordHasher <string> passwordHasher = new PasswordHasher <string>();
PasswordVerificationResult passwordVerificationResult =
passwordHasher.VerifyHashedPassword(null, user.PasswordHash, newPasswordViewModel.OldPassword);
if (!this.ModelState.IsValid || passwordVerificationResult == PasswordVerificationResult.Failed)
{
NewPasswordViewModel model = new NewPasswordViewModel()
{
UserId = newPasswordViewModel.UserId,
};
// Set invalid password error message.
this.ModelState.AddModelError("Error", "Invalid password.");
return(this.View(model));
}
user.PasswordHash = passwordHasher.HashPassword(null, newPasswordViewModel.NewPassword);
this.dataService.UpdateUser(user);
return(this.RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Password(NewPasswordViewModel form)
{
if (!ModelState.IsValid)
{
return(View());
}
var userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
var user = await unitOfWork.Users.GetAsync(userId);
try
{
if (userService.VerifyPassword(user, form.CurrentPassword))
{
await userService.UpdateAsync(user, form.NewPassword);
return(RedirectToAction("Index"));
}
ModelState.AddModelError(nameof(NewPasswordViewModel.CurrentPassword), "A senha informada não está correta.");
return(View());
}
catch (ValidationException e)
{
ModelState.AddModelError(string.Empty, e.Message);
return(View());
}
}
public ActionResult ResetPassword([Bind(Include = "AccountId,NewPassword")] NewPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = _accountService.UpdatePassword(model.AccountId, model.NewPassword);
if (result.Status == 0)
{
var userEmail = _accountService.GetUser(model.AccountId).Email;
Dictionary <string, string> kvp = new Dictionary <string, string>
{
{ "accountname", _accountService.GetUser(model.AccountId).AccountName },
};
Email.SendMail("你的【uCleaner - 打掃服務】會員密碼已重置", userEmail, Email.Template.SuccessResetPassword, kvp);
return(Json(new { response = result.Status, status = 1 }));
}
else
{
return(Json(new { response = OperationResultStatus.Fail, status = 0 }));
}
}
else
{
return(Json(new { response = OperationResultStatus.ErrorRequest, status = 0 }));
}
}
public IActionResult SifreResetleme(string codem, NewPasswordViewModel model)
{
try
{
if (!ModelState.IsValid || codem == null)
{
return(View());
}
string GelenOnayKodu = HttpContext.Session.GetString("onaykodu");
string EmailAdresi = HttpContext.Session.GetString("emailadresi");
if (GelenOnayKodu == codem)
{
var result = _ogrenciservice.EmailKontrol(EmailAdresi);
result.Data.Sifre = model.Sifre;
_ogrenciservice.Update(result.Data, 1); // 1 ise resetleme 0 ise aktif aktif değil değişimi
}
else
{
// gelen kodu yanlış girdiğinde s
}
return(RedirectToAction("Index", "Ogrenci"));
}
catch (Exception es)
{
return(null);
}
}
public static void TestValidatePropertyThatCannotBeValidated()
{
NewPasswordViewModel npvm = new NewPasswordViewModel(String.Empty, String.Empty);
string s = null;
Assert.Throws <ArgumentException>(() => { s = npvm[nameof(NewPasswordViewModel.ShowPassword)]; });
Assert.That(s, Is.Null, "Not a real assertion, only to make the variable used for FxCop.");
}
public void NewPassword(NewPasswordViewModel newPasswordViewModel)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <NewPasswordViewModel, User>());
var mapper = new Mapper(config);
User user = mapper.Map <User>(newPasswordViewModel);
accountRepository.UpdateProfile(user);
}
public static void TestValidateNonExistingPropertyName()
{
NewPasswordViewModel npvm = new NewPasswordViewModel(String.Empty, String.Empty);
string s = null;
Assert.Throws <ArgumentException>(() => { s = npvm["NonExisting"]; });
Assert.That(s, Is.Null, "Not a real assertion, only to make the variable used for FxCop.");
}
public ActionResult NewPassword(NewPasswordViewModel model)
{
if (_loginManager.ChangeNewPassword(model.Password))
{
return(RedirectToAction("Login"));
}
return(RedirectToAction("Login"));
}
public NewPasswordView(Pswmgr.PasswordEntry entry = null)
{
_ViewModel = new NewPasswordViewModel(this, entry);
DataContext = _ViewModel;
InitializeComponent();
_PasswordBox.Password = _ViewModel.Model.Password;
}
public IActionResult EditPassword()
{
NewPasswordViewModel model = new NewPasswordViewModel()
{
UserId = this.dataService.GetObjectByPropertyValue <User>("Username", this.User.Identity.Name).Id,
};
return(this.View(model));
}
public NewPasswordViewModel Newpassword(string id)
{
User user = accountRepository.Newpassword(id);
var config = new MapperConfiguration(cfg => cfg.CreateMap <User, NewPasswordViewModel>());
var mapper = new Mapper(config);
NewPasswordViewModel newPasswordViewModel = mapper.Map <NewPasswordViewModel>(user);
return(newPasswordViewModel);
}
public static void TestConstructorWithKnownDefaultIdentity(CryptoImplementation cryptoImplementation)
{
SetupAssembly.AssemblySetupCrypto(cryptoImplementation);
_identities.Add(Passphrase.Empty);
NewPasswordViewModel npvm = new NewPasswordViewModel(String.Empty, String.Empty);
Assert.That(npvm.PasswordText, Is.EqualTo(String.Empty));
}
public ActionResult RedirectToNewPassword()
{
var viewModel = new NewPasswordViewModel()
{
UserName = (string)Session["username"]
};
return(View("NewPassword", viewModel));
}
public static void TestValidatePassphraseNotOk()
{
NewPasswordViewModel npvm = new NewPasswordViewModel(String.Empty, String.Empty);
npvm.PasswordText = "abc1234";
npvm.Verification = "abc12345";
Assert.That(npvm[nameof(NewPasswordViewModel.Verification)], Is.Not.EqualTo(""));
Assert.That(npvm.ValidationError, Is.EqualTo((int)ValidationError.VerificationPassphraseWrong));
}
public static void TestShowPassphrase()
{
NewPasswordViewModel npvm = new NewPasswordViewModel("Identity", String.Empty);
Assert.That(npvm.ShowPassword, Is.False);
npvm.ShowPassword = true;
Assert.That(npvm.ShowPassword, Is.True);
}
public async Task <IActionResult> ChangePassword(NewPasswordViewModel newPassword)
{
if (!ModelState.IsValid || newPassword.Password != newPassword.ConfirmPassword)
{
return(BadRequest());
}
await _userService.ChangePasswordAsync(newPassword);
return(Ok());
}
public NewPassphraseDialog(Form parent, string title, NewPasswordViewModel viewModel)
: this()
{
InitializeStyle(parent);
Text = title;
_viewModel = viewModel;
_passphraseTextBox.TextChanged += (sender, e) => { _viewModel.PasswordText = _passphraseTextBox.Text; ClearErrorProviders(); };
_passphraseTextBox.TextChanged += async(sender, e) => { await _passwordStrengthMeter.MeterAsync(_passphraseTextBox.Text); };
_verifyPassphraseTextbox.TextChanged += (sender, e) => { _viewModel.Verification = _verifyPassphraseTextbox.Text; ClearErrorProviders(); };
_showPassphraseCheckBox.CheckedChanged += (sender, e) => { _viewModel.ShowPassword = _showPassphraseCheckBox.Checked; };
}
public static void TestValidateWrongPassphraseWithRealFile(CryptoImplementation cryptoImplementation)
{
SetupAssembly.AssemblySetupCrypto(cryptoImplementation);
FakeDataStore.AddFile(@"C:\My Folder\MyFile-txt.axx", new MemoryStream(Resources.helloworld_key_a_txt));
NewPasswordViewModel npvm = new NewPasswordViewModel(String.Empty, @"C:\My Folder\MyFile-txt.axx");
npvm.PasswordText = "b";
npvm.Verification = "b";
Assert.That(npvm[nameof(NewPasswordViewModel.PasswordText)], Is.Not.EqualTo(""));
Assert.That(npvm.ValidationError, Is.EqualTo((int)ValidationError.WrongPassphrase));
}
public ActionResult NewPassword(NewPasswordViewModel validmodel)
{
if (ModelState.IsValid)
{
var vm = new ViewModels();
var username = validmodel.username;
var user = database.Users.Where(a => a.Username == username).FirstOrDefault();
user.Password = vm.encryptPassword(validmodel.ConfirmPassword);
database.SaveChanges();
TempData["newPasswordstatus"] = "success";
}
return(RedirectToAction("login"));
}
public ActionResult NewPassword(NewPasswordViewModel newPasswordViewModel)
{
if (ModelState.IsValid)
{
accountService.NewPassword(newPasswordViewModel);
return(RedirectToAction("Login"));
}
else
{
ModelState.AddModelError("", "error");
return(View());
}
}
public static void TestValidatePassphraseOk()
{
TypeMap.Register.New <AxCryptFactory>(() => new AxCryptFactory());
TypeMap.Register.Singleton <PasswordStrengthEvaluator>(() => new PasswordStrengthEvaluator(64, 0));
NewPasswordViewModel npvm = new NewPasswordViewModel(String.Empty, String.Empty);
npvm.PasswordText = "Loadiney4aropRout[";
npvm.Verification = "Loadiney4aropRout[";
Assert.That(npvm[nameof(NewPasswordViewModel.PasswordText)], Is.EqualTo(""));
Assert.That(npvm[nameof(NewPasswordViewModel.Verification)], Is.EqualTo(""));
Assert.That(npvm.ValidationError, Is.EqualTo((int)ValidationError.None));
}
public async Task <IActionResult> SetPassword(NewPasswordViewModel model)
{
if (ModelState.IsValid)
{
await httpHandler.SetPassword(model.Password, model.Code);
return(Redirect("/Account/Login"));
}
var vm = new VerifyViewModel()
{
CodeExists = true, InvalidPassword = true
};
return(View("Verify", vm));
}
public ActionResult NewPassword(string id)
{
// NewPasswordViewModel newPasswordViewModel = accountService.NewPassword(Convert.ToString(Session["Email"]));
NewPasswordViewModel newPasswordViewModel = accountService.Newpassword(id);
if (newPasswordViewModel != null)
{
return(View(newPasswordViewModel));
}
else
{
return(HttpNotFound());
}
// return View(newPasswordViewModel);
}
public async Task <IActionResult> ResetPasswordConfirmed(NewPasswordViewModel model)
{
var result = await this.userManager.SetPasswordAsync(model.UserId, model.NewPassword);
if (!result.Success)
{
throw new InvalidOperationException(
$"An error occured while trying to reset password for user with ID: '{model.UserId}'.");
}
this.ShowNotification(
"Your password was reset successfully. Now you can sign in with your new password.",
NotificationType.Success);
return(RedirectToLogin());
}
public async Task ChangePasswordAsync(NewPasswordViewModel model)
{
var user = await _unitOfWork.UserRepository.GetAsync(model.UserId);
if (user == null)
{
throw new ApiException(HttpStatusCode.NotFound, "User was not found");
}
if (!_hasher.CheckPassWithHash(model.OldPassword, user.Password))
{
throw new ApiException(HttpStatusCode.BadRequest, "Old password incorrect");
}
user.Password = _hasher.HashPassword(model.Password);
await _unitOfWork.Complete();
}
public IActionResult ResetPassword(string email, string token)
{
//var user = await UserManager.FindByEmailAsync(email);
//if (user == null)
// return RedirectToAction("ForgotPasswordConfirmation", "Account", new { confirmationText = "Nie odnaleziono użytkownika" });
//var correctToken = await UserManager.GeneratePasswordResetTokenAsync(user);
//correctToken = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(correctToken));
//if (correctToken != token)
// return RedirectToAction("ForgotPasswordConfirmation", "Account", new { confirmationText = "Token jest niepoprawny" });
var model = new NewPasswordViewModel
{
Email = email,
Token = token
};
return(View(model));
}
public async Task <IHttpActionResult> UpdatePassword(NewPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = await _repoUser.FindByNameAsync(User.Identity.Name);
var result = await _repoUser.ResetPasswordAsync(user.Id, model.Password);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(BadRequest(errorResult.ToString()));
}
return(Ok());
}
public async Task <ActionResult> NewPassword(NewPasswordViewModel model)
{
var userName = model.UserName;
var user = UserManager.FindByName(userName);
if (user == null)
{
ModelState.AddModelError("", "Invalid username.");
return(View(model));
}
else
{
var newPassword = model.NewPassword;
user.PasswordHash = UserManager.PasswordHasher.HashPassword(newPassword);
UserManager.Update(user);
IdentityResult result = UserManager.Update(user);
return(RedirectToAction("Login", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
}
