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 })); } }