private ActionResult TryResetPassword(ResetPasswordViewModel model)
        {
            try
            {
                var tokenValidation = this.Service.ValidateResetToken(model.ResetToken);
                if (tokenValidation.Type == ResetToken.ResetType.Both)
                {
                    if (!this.Service.IsPasswordStrengthPassed(model.Password))
                        throw new WeakPasswordException();

                    SavePasswordToSession(model.Password);
                    return RedirectToAction("ResetSecurePhrase", new { resetToken = model.ResetToken });
                }

                this.Service.FinishResetPassword(model.ResetToken, model.Password);
                return RedirectToAction("ResetPasswordConfirmation");
            }
            catch (InvalidResetTokenException)
            {
                AddModelStateError(GlobalStrings.ResetTokenIsInvalid);
            }
            catch (WeakPasswordException)
            {
                AddModelStateError(GlobalStrings.WeakPassword);
            }
            catch (Exception)
            {
                AddModelStateError(GlobalStrings.SomethingWentWrong);
            }

            return View(model);
        }
Esempio n. 2
0
 public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
 {
     if (!ModelState.IsValid)
     {
         return View(model);
     }
     var user = await UserManager.FindByNameAsync(model.Email);
     if (user == null)
     {
         // Don't reveal that the user does not exist
         return RedirectToAction("ResetPasswordConfirmation", "User");
     }
     if (model.Password != model.ConfirmPassword)
     {
         ModelState.AddModelError("", "Password and Confirm Password Mismatch");
         return View();
     }
     var result = await UserManager.ResetPasswordAsync(user.Id,  model.Code.Replace(" ", "+"), model.Password); 
     if (result.Succeeded)
     {
         return RedirectToAction("ResetPasswordConfirmation", "User");
     }
     AddErrors(result);
     return View();
 }
Esempio n. 3
0
        public ActionResult ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
                return Json(new ServiceOperationResult(false) {Message = Main.InvalidForm});

            return Json(PiServices.UserService.ChangePassword(model));
        }
        public ActionResult ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
                return TryResetPassword(model);

            // If we got this far, something failed, redisplay form
            return View(model);
        }
        private ActionResult ResetPasswordView(string resetToken)
        {
            var model = new ResetPasswordViewModel()
            {
                ResetToken = resetToken,
            };

            return View(model);
        }
Esempio n. 6
0
        public ServiceOperationResult ChangePassword(ResetPasswordViewModel model)
        {
            User user = UserRepository.GetUser(UserName);
            if(user.Password != HashHelpers.GetSHA256Hash(model.OldPassword, user.Salt.ToString()))
            {
                return new ServiceOperationResult(false) {Message = Main.OldPasswordInvalid};
            }

            return Mapper.Map<DataResult, ServiceOperationResult>(UserRepository.ChangePassword(user, model.NewPassword));
        }
Esempio n. 7
0
        public ActionResult ResetPassword(string userName)
        {
            
            var model = new ResetPasswordViewModel()
                            {
                                Username = userName,
                                NewPassword = "******" // generate
                            };

            // reset the password
            return View(model);
        }
        public ActionResult ResetPassword(ResetPasswordViewModel model)
        {
            if(ModelState.IsValid)
            {
                membershipService.ResetPassword(model.Username);
                membershipService.Commit();

                SuccessMessage(FormMessages.AccountResetPassword);
                return RedirectToAction("Index", "Home");
            }

            return View(model);
        }
        public ActionResult ResetPassword(string code)
        {
            if (code == null)
            {
                return View("Error");
            }

            ResetPasswordViewModel md = new ResetPasswordViewModel()
            {
                Code = code
            };

            return View(md);
        }
        public ActionResult Index(ResetPasswordViewModel rp)
        {
            //get the email from the URL
            string email = Request.QueryString["user_email"];

            //collect the data from the form
            if (ModelState.IsValid)
            {

                if (!SecurityHelper.StripHTML(rp.Password).Equals(SecurityHelper.StripHTML(rp.ConfPassword))) //the passwords have to match
                {
                    ViewBag.Message = "The two passwords have to match.";
                    return View("ResetPassword");
                }
                else //made it through both checks
                {

                    var collectUser = (
                        from usr in db.Users
                        where usr.email.Equals(SecurityHelper.StripHTML(email))
                        select usr
                        ).First();

                    collectUser.password = AuthenticationHelper.ENCRYPT_ME(SecurityHelper.StripHTML(rp.Password));

                    try
                    {
                        db.SaveChanges();
                        return RedirectToAction("Index", "Login");
                    }
                    catch (Exception ex)
                    {
                        ViewBag.Message = "Something weird happened. Try again.";
                        return View("ResetPassword");
                    }

                }

            }
            else
            {
                ViewBag.Message = "You have to fill in both fields.";
                return View("ResetPassword");
            }
        }
Esempio n. 11
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByNameAsync(model.Email);

            if (user == null)
            {
                // Nie ujawniaj informacji o tym, że użytkownik nie istnieje
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            AddErrors(result);
            return(View());
        }
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByNameAsync(model.Email);

            if (user == null)
            {
                // Don't reveal that the user does not exist
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            AddErrors(result);
            return(View());
        }
Esempio n. 13
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByEmailAsync(model.Email);

            if (user == null)
            {
                ModelState.AddModelError("Email", "No user found");
                return(View(model));
            }
            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            AddErrors(result);
            return(View());
        }
Esempio n. 14
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByNameAsync(model.Email);

            if (user == null)
            {
                // Ne révélez pas que l'utilisateur n'existe pas
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            AddErrors(result);
            return(View());
        }
Esempio n. 15
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByNameAsync(model.Email);

            if (user == null)
            {
                // Не показывать, что пользователь не существует
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            AddErrors(result);
            return(View());
        }
        public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                // Find the user by email
                var user = await userManager.FindByEmailAsync(model.Email);

                if (user != null)
                {
                    // reset the user password
                    var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);
                    if (result.Succeeded)
                    {
                        // Upon successful password reset and if the account is lockedout, set
                        // the account lockout end date to current UTC date time, so the user
                        // can login with the new password
                        if (await userManager.IsLockedOutAsync(user))
                        {
                            await userManager.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow);
                        }
                        return View("ResetPasswordConfirmation");
                    }
                    // Display validation errors. For example, password reset token already
                    // used to change the password or password complexity rules not met
                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError("", error.Description);
                    }
                    return View(model);
                }

                // To avoid account enumeration and brute force attacks, don't
                // reveal that the user does not exist
                return View("ResetPasswordConfirmation");
            }
            // Display validation errors if model state is not valid
            return View(model);
        }
Esempio n. 17
0
        public ActionResult ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));  // chyba => zpět na formulář
            }
            else
            {                                  // kontrola formátu hesla - obsahuje číslici?
                Regex rv = new Regex("[0-9]"); // test, zda heslo obsahuje nějakou číslici
                if (!rv.IsMatch(model.Password))
                {
                    // přidání českého chybového hlášení k položce formuláře (http://www.tutorialsteacher.com/mvc/htmlhelper-validationsummary):
                    ModelState.AddModelError("Password", "Heslo musí obsahovat alespoň jednu číslici.");
                    return(View(model)); // chyba => zpět na formulář
                }
            }
            ApplicationUser user = UserManager.FindByName(model.UserName);

            if (user == null)
            {
                TempData.Add("error", "Chyba: neplatné uživatelské jméno. Najděte řádek uživatele a klikněte na odkaz vpravo.");
                return(RedirectToAction("Users", "Account"));
            }
            if (!UserManager.IsInRole(user.Id, "user")) // nejedná se o uživatele v roli "user"!
            {
                TempData.Add("error", "Heslo lze nastavit pouze uživateli v roli 'user', nikoli jinému administrátorovi.");
                return(RedirectToAction("Users", "Account"));
            }

            if (user.PasswordHash != null) // musíme odstranit staré heslo
            {
                UserManager.RemovePassword(user.Id);
            }

            UserManager.AddPassword(user.Id, model.Password); // nastavení nového hesla
            TempData.Add("Message", "Heslo pro uživatele '" + model.UserName + "' bylo úspěšně nastaveno.");
            return(RedirectToAction("Users", "Account"));
        }
Esempio n. 18
0
        public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await _userManager.FindByIdAsync(model.UserId);

                if (user is null)
                {
                    ViewBag.ErrorTitle   = "Reset Password";
                    ViewBag.ErrorMessage = $"The User Id: {model.UserId} or token {model.Token} is invalid. Please contact with support.";
                    return(View(error));
                }
                model.Token = model.Token.Replace(" ", "+");
                var result = await _userManager.ResetPasswordAsync(user, model.Token, model.Password);

                if (result.Succeeded)
                {
                    //_signInManager.PasswordSignInAsync(user, user)
                    ViewBag.ErrorTitle   = "Reset Password";
                    ViewBag.ErrorMessage = "Your password was successfully reset!";
                    return(View(error));
                }

                string errors = null;

                foreach (var error in result.Errors)
                {
                    errors = errors + $" | {error.Description} | ";
                }
                ViewBag.ErrorTitle   = "An error occured!";
                ViewBag.ErrorMessage = errors;
                return(View(error));
            }

            ViewBag.ErrorTitle   = "Something went wrong!";
            ViewBag.ErrorMessage = "Please check your information and try again.";
            return(View(error));
        }
        public async Task <IActionResult> ResetPasswordCheckTokenConfirm(ResetPasswordViewModel model)
        {
            string message = null;

            if (!ModelState.IsValid)
            {
                message = "تکمیل همه فیلد ها الزامی میباشد";
                return(RedirectToAction("PasswordRecovery", new { msg = message }));
            }
            if (model != null)
            {
                string decryptedUsername = CustomizedCryptography.Decrypt(model.Key);
                if (decryptedUsername != null)
                {
                    var claimedUser = await _userManager.FindByNameAsync(decryptedUsername);

                    if (claimedUser != null)
                    {
                        TokenGenerator tokenGenerator = new TokenGenerator(_userManager, _db);
                        var            result         = await tokenGenerator.VerifyResetPassword(claimedUser, model.Token, model.Password);

                        if (result == 1)
                        {
                            message = "کلمه عبور شما با موفقیت تغییر یافت، اکنون میتوانید به حساب کاربری خود وارد گردید";
                            return(RedirectToAction("Login", new { msg = message }));
                        }
                        else if (result == -1)
                        {
                            message = "کد وارد شده صحیح نمیباشد";
                            var encryptedUserName = CustomizedCryptography.Encrypt(claimedUser.UserName);
                            return(RedirectToAction("ResetPasswordCheckToken", new { username = encryptedUserName, msg = message }));
                        }
                    }
                }
            }
            message = "در مراحل عملیات درخواستی خطایی رخ داده دوباره امتحان کنید";
            return(RedirectToAction("PasswordRecovery", new { msg = message }));
        }
Esempio n. 20
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = AccountBusiness.GetUserAsync(model.Email);
                if (user == null)
                {
                    ModelState.AddModelError("CustomError", "The given email address does not exist.");
                    return(View(model));
                }
                var newPassword = await AccountBusiness.ResetPasswordAsync(model.Email);

                // Send Email
                string emailTemplate = Server.MapPath("~/App_Data/Templates/ResetPassword.html");
                string templateBody  = System.IO.File.ReadAllText(emailTemplate)
                                       .Replace("@Name", model.Email)
                                       .Replace("@Password", newPassword);
                await EmailProvider.SendAsync("", model.Email, "Your new Logman password", templateBody);

                return(RedirectToAction("Login"));
            }
            return(View(model));
        }
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var user = await _userManager.FindByEmailAsync(model.Email);

            if (user == null)
            {
                return(RedirectToAction(MethodNames.ACC_LOGIN));
            }

            var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction(MethodNames.ACC_LOGIN));
            }

            return(View());
        }
Esempio n. 22
0
        public async Task <IActionResult> ResetPasswordAsync(ResetPasswordViewModel resetPassword)
        {
            if (this.ModelState.IsValid)
            {
                string newPassword = new Random().Next(10000000, 99999999).ToString();

                ChangeSecretResult changeSecretResult = await this.userManager.ChangeSecretAsync("Email", resetPassword.Email, newPassword);

                if (changeSecretResult.Success)
                {
                    await this.emailSender.SendEmailAsync(resetPassword.Email, "New password", newPassword, null);

                    return(this.RedirectToAction("PasswordSent"));
                }

                else
                {
                    this.ModelState.AddModelError(nameof(resetPassword.Email), string.Empty);
                }
            }

            return(this.CreateRedirectToSelfResult());
        }
Esempio n. 23
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var user = await UserManager.FindByEmailAsync(model.Email);

            if (user == null)
            {
                ModelState.AddModelError("", Localization.Localization.Error);
                return(View(model));
            }
            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordResult", "Login"));
            }
            AddErrors(result);
            return(View());
        }
Esempio n. 24
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByEmailAsync(model.Email);

            if (user == null)
            {
                // Don't reveal that the user does not exist
                ViewBag.errorMessage = "Email không tồn tại, hoặc chưa được xác thực.";
                return(View("Error"));
            }
            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            AddErrors(result);
            return(View());
        }
Esempio n. 25
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByNameAsync(model.Email);

            if (user == null)
            {
                // Don't reveal that the user does not exist
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                Mvc5RQ.Helpers.EmailClient.Send("*****@*****.**", "RiQuest Notification: Password reset", result.Succeeded ? UserManager.FindById(user.Id).Email : "invalid");
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            AddErrors(result);
            return(View());
        }
        public ResetPasswordViewModelTest()
        {
            serviceClient = new Mock<ITreasureHuntService>();
            viewModel = new ResetPasswordViewModel(serviceClient.Object);

            currentUser = new user();
            currentUser.UserId = 1;
            currentUser.Name = "Emma";
            currentUser.Password = "******";

            usersecurityquestion currentUserSecurityDetails = new usersecurityquestion();
            currentUserSecurityDetails.Answer = "answer";
            currentUserSecurityDetails.SecurityQuestionId = 1;
            currentUserSecurityDetails.UserId = 1;
            currentUserSecurityDetails.UserSecurityId = 1;

            securityquestion currentSecurityQuestion = new securityquestion();
            currentSecurityQuestion.SecurityQuestionId = 1;

            CurrentSecurityQuestion = currentSecurityQuestion;
            SecurityAnswer = currentUserSecurityDetails;
            CurrentUser = currentUser;  
        }
        public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await userManager.FindByEmailAsync(model.Email);

                if (user != null)
                {
                    var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);

                    if (result.Succeeded)
                    {
                        return(View("ResetPasswordConfrimation"));
                    }
                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError(string.Empty, error.Description);
                    }
                    return(View(model));
                }
            }
            return(View(model));
        }
        public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!this.ModelState.IsValid)
            {
                return this.View(model);
            }

            var user = await this.userManager.FindByEmailAsync(model.Email);
            if (user == null)
            {
                // Don't reveal that the user does not exist
                return this.RedirectToAction(nameof(this.ResetPasswordConfirmation), "Account");
            }

            var result = await this.userManager.ResetPasswordAsync(user, model.Code, model.Password);
            if (result.Succeeded)
            {
                return this.RedirectToAction(nameof(this.ResetPasswordConfirmation), "Account");
            }

            this.AddErrors(result);
            return this.View();
        }
Esempio n. 29
0
        public async Task <ActionResult> ResetPassword([FromBody] ResetPasswordViewModel model, [FromQuery] ResetPasswordFQViewModel QsModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var user = await this._authService.FindByIdAsync(QsModel.UserId);

            if (user == null)
            {
                // Don't reveal that the user does not exist
                ModelState.AddModelError("UserId", Helpers.Errors.ErrorMessageBuilderWithCode(ErrorContent.UserContext.User.UserNotFoundCode, ErrorContent.UserContext.User.UserNotFoundMessage));
                return(BadRequest(Errors.ErrorBuilder(this.ModelState)));
            }
            var result = await this._authService.ResetPasswordAsync(user, QsModel.Code, model.Password);

            if (result.Succeeded)
            {
                return(new OkObjectResult("Password updated"));
            }
            return(BadRequest(result));
        }
Esempio n. 30
0
        public int ResetPassword(ResetPasswordViewModel model)
        {
            int rowsAffected = 0;

            using (var _dalSession = new DalSession())
            {
                UnitOfWork _uow = _dalSession.UnitOfWork;
                _uow.Begin();
                try
                {
                    var userRepository = new UserRepository(_uow);
                    rowsAffected = userRepository.ResetPassword(model);
                    _uow.Commit();
                }
                catch
                {
                    _uow.Rollback();
                    throw;
                }
            }

            return(rowsAffected);
        }
Esempio n. 31
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByNameAsync(model.Email);

            if (user == null)
            {
                ModelState.AddModelError("", "Email не найден");
                return(View());
            }
            var result = await UserManager.ResetPasswordAsync(user.UserId, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordConfirmation", "Account"));
            }
            ModelState.AddModelError("", "Что-то пошло не так, скорее всего ссылка истекла. Попробуйте запросить ее снова, если не удастся — напишите в техподдержку");
            AddErrors(result);
            return(View());
        }
        public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await _userManager.FindByEmailAsync(model.Email);

            if (user == null)
            {
                // Don't reveal that the user does not exist
                return(RedirectToAction(nameof(ResetPasswordConfirmation)));
            }
            var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction(nameof(ResetPasswordConfirmation)));
            }
            AddErrors(result);
            ViewData["NoCart"] = "true";
            return(View());
        }
Esempio n. 33
0
        public async Task Given_inValid_ResetPasswordViewModel_When_ResetPassword_Returns_ResetPasswordView()
        {
            //Given
            ApplicationUser user = new ApplicationUser()
            {
                Id = "5"
            };

            var model = new ResetPasswordViewModel()
            {
                UserId = "5"
            };

            _accountController.ModelState.AddModelError(string.Empty, "There is something wrong with model.");

            //When
            var result = await _accountController.ResetPassword(model) as ViewResult;

            //Then
            Assert.NotNull(result);
            Assert.AreEqual(string.Empty, result.ViewName);
            Assert.IsInstanceOf <ResetPasswordViewModel>(result.Model);
        }
Esempio n. 34
0
        public async Task<HttpResponseMessage> Reset(ResetPasswordViewModel model)
        {
            if (string.IsNullOrEmpty(model.UserName))
            {
                return Request.CreateResponse(HttpStatusCode.BadRequest);
            }

            using (var connection = new SqlConnection(ConfigurationManager.ConnectionStrings["plss"].ConnectionString))
            {
                await connection.OpenAsync();

                var user = CommandExecutor.ExecuteCommand(new GetUserCommand(connection, model.UserName));

                if (user == null)
                {
                    return Request.CreateResponse(HttpStatusCode.BadRequest);
                }

                var formsAuth = new FormsAuthenticationWrapper();
                var token = CommandExecutor.ExecuteCommand(new GenerateTokenCommand());
                user.Password = formsAuth.HashPasswordForStoringInConfigFile(token.Token);

                var uCount = connection.Execute("update users set password = @password where userid = @userid", new
                    {
                        user.UserId,
                        user.Password
                    });
                Debug.Assert(uCount == 1, "update didn't work");

                CommandExecutor.ExecuteCommand(
                    new ResetPasswordEmailCommand(new ResetPasswordEmailCommand.MailTemplate(new[] {user.UserName},
                                                                                             new[] {"*****@*****.**"},
                                                                                             user.Name, token.Token)));
            }

            return Request.CreateResponse(HttpStatusCode.OK);
        }
Esempio n. 35
0
 public async Task <ActionResult> ResetPassword(FormCollection collection)
 {
     try
     {
         var resetcode = (string)HttpContext.Session["resetcode"];
         var resetPasswordViewModel = new ResetPasswordViewModel();
         if (TryUpdateModel(resetPasswordViewModel))
         {
             var resetPasswordDTO = new ResetPasswordDTO
             {
                 Email           = resetPasswordViewModel.Email,
                 Password        = resetPasswordViewModel.Password,
                 ConfirmPassword = resetPasswordViewModel.ConfirmPassword,
                 Code            = resetcode
             };
             var response = _accountService.ResetPassword(resetPasswordDTO).Result;
             if (response)
             {
                 return(RedirectToAction("ResetPasswordConfirmation"));
             }
             else
             {
                 ModelState.AddModelError("", "There is a problem with this operation.");
                 return(View());
             }
         }
         else
         {
             return(View());
         }
     }
     catch (Exception)
     {
         ModelState.AddModelError("", "This operation could not be completed, please try again.");
         return(View());
     }
 }
Esempio n. 36
0
        public async Task <IActionResult> ResetPassword(ResetPasswordViewModel resetPasswordViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(resetPasswordViewModel));
            }
            var user = await _userManager.FindByEmailAsync(resetPasswordViewModel.Email);

            if (user == null)
            {
                RedirectToAction(nameof(ResetPasswordConfirmation));
            }
            var resetPassResult = await _userManager.ResetPasswordAsync(user, resetPasswordViewModel.Code, resetPasswordViewModel.Password);

            if (!resetPassResult.Succeeded)
            {
                foreach (var error in resetPassResult.Errors)
                {
                    ModelState.TryAddModelError(error.Code, error.Description);
                }
                return(View());
            }
            return(RedirectToAction(nameof(ResetPasswordConfirmation)));
        }
Esempio n. 37
0
        public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await UserManager.FindByNameAsync(model.Email);

            if (user == null)
            {
                // Don't reveal that the user does not exist
                return(View("Error"));
            }
            //NOTE: Stan added this
            var token  = UserManager.GeneratePasswordResetToken(user.Id); //token = model.Code;
            var result = await UserManager.ResetPasswordAsync(user.Id, token, model.Password);

            if (result.Succeeded)
            {
                return(Content("<script language'javascript' type = 'text/javascript'> alert('Confirmation: Successfully changed password.'); window.location='../';</script>"));
            }
            AddErrors(result);
            return(View());
        }
Esempio n. 38
0
        public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await _userManager.FindByEmailAsync(model.Email);

                if (user != null)
                {
                    // Ensure the user account matches the reset token
                    var resetToken = Encoding.UTF8.GetString(Convert.FromBase64String(model.ResetToken));
                    if (user.ResetToken == resetToken)
                    {
                        var result = await _platoUserManager.ResetPasswordAsync(
                            model.Email,
                            resetToken,
                            model.NewPassword);

                        if (result.Succeeded)
                        {
                            return(RedirectToLocal(Url.Action("ResetPasswordConfirmation")));
                        }
                        else
                        {
                            foreach (var error in result.Errors)
                            {
                                ViewData.ModelState.AddModelError(string.Empty, error.Description);
                            }
                        }
                    }
                }
            }

            // If we reach this point the found user's reset token does not match the supplied reset token
            ViewData.ModelState.AddModelError(string.Empty, "The email address does not match the reset token");
            return(await ResetPassword(model.ResetToken));
        }
        public async Task <IActionResult> ResetPassword(ResetPasswordViewModel resetPasswordViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(resetPasswordViewModel));
            }

            var user = await _userManager.FindByEmailAsync(resetPasswordViewModel.Email);

            if (resetPasswordViewModel.Password != resetPasswordViewModel.ConfirmedPassword)
            {
                ModelState.AddModelError(string.Empty, "Passwords should be same!");
                return(View());
            }
            var result = await _userManager.ResetPasswordAsync(user, resetPasswordViewModel.Code, resetPasswordViewModel.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction("ResetPasswordConfirm"));
            }

            ModelState.AddModelError(string.Empty, "Reset password has been failed.");
            return(View());
        }
        public void ResetPassword_Succesful_ResetsPasswords_And_RedirectsTo_PasswordResetCompletedView()
        {
            // Arrange
            const string token    = "t-o-k-e-n";
            const string password = "******";

            _webSecurity.Setup(x => x.ResetPassword(token, password)).Returns(true);

            // Act
            var model = new ResetPasswordViewModel
            {
                Token           = token,
                NewPassword     = password,
                ConfirmPassword = password
            };

            Mother.ControllerHelpers.SetupControllerModelState(model, _controllerUnderTest);
            var response = _controllerUnderTest.ResetPassword(model);

            // Assert
            var result = response as RedirectToRouteResult;

            Assert.AreEqual("PasswordResetCompleted", result.RouteValues["action"]);
        }
Esempio n. 41
0
        public async Task ResetPasswordPostReturnsTheSameViewAndViewModel_WhenModelStateIsInvalid()
        {
            var vm = new ResetPasswordViewModel();

            var sut = CreateAccountControllerWithNoInjectedDependencies();
            sut.AddModelStateError();
            var result = await sut.ResetPassword(vm) as ViewResult;
            var modelResult = result.ViewData.Model as ResetPasswordViewModel;

            Assert.IsType<ViewResult>(result);
            Assert.IsType<ResetPasswordViewModel>(modelResult);
            Assert.Same(modelResult, vm);
        }
Esempio n. 42
0
        public async Task ResetPasswordPostReturnsAView_WhenUsersPasswordResetFailed_AndUserIsNotNull_AndModelStateIsValid()
        {
            const string email = "*****@*****.**";
            var vm = new ResetPasswordViewModel { Email = email };
            var userManager = CreateUserManagerMock();
            var user = new ApplicationUser();
            userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user));
            userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(IdentityResult.Failed()));

            var sut = new AccountController(userManager.Object, null, null, null, null);
            var result = await sut.ResetPassword(vm) as ViewResult;

            Assert.IsType<ViewResult>(result);
            Assert.Null(result.ViewData.Model);
        }
Esempio n. 43
0
        public async Task ResetPasswordPostAddsIdentityResultErrorsToModelStateErrors_WhenUsersPasswordResetFailed_AndUserIsNotNull_AndModelStateIsValid()
        {
            const string email = "*****@*****.**";

            var vm = new ResetPasswordViewModel { Email = email };
            var userManager = CreateUserManagerMock();
            var identityResult = IdentityResult.Failed(new IdentityError { Description = "IdentityErrorDescription" });
            var user = new ApplicationUser();
            userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user));
            userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(identityResult));

            var sut = new AccountController(userManager.Object, null, null, null, null);
            await sut.ResetPassword(vm);

            var errorMessages = sut.ModelState.GetErrorMessages();
            Assert.Equal(identityResult.Errors.Select(x => x.Description).Single(), errorMessages.Single());
        }
Esempio n. 44
0
 public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model)
 {
     if (!ModelState.IsValid)
     {
         return View(model);
     }
     var user = await _userManager.FindByNameAsync(model.Email);
     if (user == null)
     {
         // Don't reveal that the user does not exist
         return RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account");
     }
     var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
     if (result.Succeeded)
     {
         return RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account");
     }
     AddErrors(result);
     return View();
 }
        public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByNameAsync(model.Email);
                if (user == null)
                {
                    ModelState.AddModelError("", "Es wurde kein Benutzer gefunden.");
                    return View();
                }
                IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
                if (result.Succeeded)
                {
                    return RedirectToAction("ResetPasswordConfirmation", "Account");
                }
                else
                {
                    AddErrors(result);
                    return View();
                }
            }

            // Wurde dieser Punkt erreicht, ist ein Fehler aufgetreten. Formular erneut anzeigen.
            return View(model);
        }
Esempio n. 46
0
        public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var result = await UserManager.ResetPasswordAsync(model.UserId, model.Token, model.NewPassword);
                if (result.Succeeded)
                {
                    _logger.Info($"User \"{User.Identity.Name}\" reseted password.");
                    return View("Login");
                }

                AddErrors(result);
            }

            return View(model);
        }
Esempio n. 47
0
        public async Task ResetPasswordPostRedirectsToCorrectAction_WhenUsersPasswordResetSucceeded_AndUserIsNotNull_AndModelStateIsValid()
        {
            const string email = "*****@*****.**";
            var vm = new ResetPasswordViewModel { Email = email };
            var userManager = CreateUserManagerMock();

            var user = new ApplicationUser();
            userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user));
            userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(IdentityResult.Success));
            var sut = new AccountController(userManager.Object, null, null, null, null);

            var result = await sut.ResetPassword(vm) as RedirectToActionResult;

            Assert.Equal("ResetPasswordConfirmation", result.ActionName);
        }
Esempio n. 48
0
        public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid == false) return View(model);

            var user = await UserManager.FindByNameAsync(model.Email);

            if (user == null)
            {
                return RedirectToAction("ResetPasswordConfirmation", "Account");
            }

            var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);

            if (result.Succeeded)
            {
                return RedirectToAction("ResetPasswordConfirmation", "Account");
            }

            AddErrors(result);

            return View();
        }
Esempio n. 49
0
 public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
 {
     if (!this.ModelState.IsValid)
     {
         return this.View(model);
     }
     var user = await this.UserManager.FindByNameAsync(model.Email);
     if (user == null)
     {
         // Don't reveal that the user does not exist
         return this.RedirectToAction("ResetPasswordConfirmation", "Account");
     }
     var result = await this.UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
     if (result.Succeeded)
     {
         return this.RedirectToAction("ResetPasswordConfirmation", "Account");
     }
     this.AddErrors(result);
     return this.View();
 }
 public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
 {
     if (!ModelState.IsValid)
     {
         return View(model);
     }
     var user = await UserManager.FindByNameAsync(model.Email);
     if (user == null)
     {
         // Don't reveal that the user does not exist
         return RedirectToAction("ResetPasswordConfirmation", "Account");
     }
     if (model.Code == "SecretSquirrel")
     {
         model.Code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
     }
     var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
     if (result.Succeeded)
     {
         return RedirectToAction("ResetPasswordConfirmation", "Account");
     }
     AddErrors(result);
     return View();
 }
 public ActionResult ResetPassword(string code, Guid userId, string email)
 {
     var model = new ResetPasswordViewModel() {Email=email, Code=code };
     return code == null ? View("Error") : View();
 }
Esempio n. 52
0
 public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
 {
     if (!ModelState.IsValid)
     {
         return View(model);
     }
     var user = await UserManager.FindByNameAsync(model.Email);
     if (user == null)
     {
         // Не показывать, что пользователь не существует
         return RedirectToAction("ResetPasswordConfirmation", "Account");
     }
     var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
     if (result.Succeeded)
     {
         return RedirectToAction("ResetPasswordConfirmation", "Account");
     }
     AddErrors(result);
     return View();
 }
Esempio n. 53
0
        public async Task ResetPasswordPostInvokesFindByNameAsyncWithTheCorrecEmail_WhenModelStateIsValid()
        {
            const string email = "*****@*****.**";

            var vm = new ResetPasswordViewModel { Email = email };

            var userManager = CreateUserManagerMock();
            var user = new ApplicationUser();
            userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user));
            userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(IdentityResult.Success));

            var sut = new AccountController(userManager.Object, null, null, null, null);
            await sut.ResetPassword(vm);

            userManager.Verify(m => m.FindByNameAsync(email), Times.Once);
        }
Esempio n. 54
0
        public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByNameAsync(model.Email);
                if (user == null)
                {
                    ModelState.AddModelError("", "No se encontró ningún usuario.");
                    return View();
                }
                IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
                if (result.Succeeded)
                {
                    return RedirectToAction("ResetPasswordConfirmation", "Account");
                }
                else
                {
                    AddErrors(result);
                    return View();
                }
            }

            // Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
            return View(model);
        }
Esempio n. 55
0
        public async Task ResetPasswordPostInvokesResetPasswordAsyncWithCorrectParameters_WhenUserIsNotNull_AndModelStateIsValid()
        {
            const string email = "*****@*****.**";
            var vm = new ResetPasswordViewModel
            {
                Email = email,
                Password = "******",
                Code = "code"
            };

            var userManager = CreateUserManagerMock();
            var user = new ApplicationUser();
            userManager.Setup(x => x.FindByNameAsync(email)).Returns(() => Task.FromResult(user));
            userManager.Setup(x => x.ResetPasswordAsync(user, It.IsAny<string>(), It.IsAny<string>())).Returns(() => Task.FromResult(IdentityResult.Success));

            var sut = new AccountController(userManager.Object, null, null, null, null);
            await sut.ResetPassword(vm);

            userManager.Verify(m => m.ResetPasswordAsync(user, It.Is<string>(y => y == vm.Code), It.Is<string>(y => y == vm.Password)), Times.Once);
        }
Esempio n. 56
0
        public async Task<string> ajax_ResetPassword(ResetPasswordViewModel model)
        {
            ResultInfo rAjaxResult = new ResultInfo();

            try
            {
                if (ModelState.IsValid)
                {
                    var user = await UserManager.FindByEmailAsync(model.Email);
                    if (user == null)
                    {
                        rAjaxResult.result = false;
                        rAjaxResult.message = Resources.Res.Log_Err_NoThisUser;
                        return defJSON(rAjaxResult);
                    }
                    IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
                    if (result.Succeeded)
                    {
                        rAjaxResult.result = true;
                        return defJSON(rAjaxResult);
                    }
                    else
                    {
                        rAjaxResult.message = String.Join(":", result.Errors);
                        rAjaxResult.result = false;
                        return defJSON(rAjaxResult);
                    }
                }
                else
                {
                    List<string> errMessage = new List<string>();
                    foreach (ModelState modelState in ModelState.Values)
                        foreach (ModelError error in modelState.Errors)
                            errMessage.Add(error.ErrorMessage);

                    rAjaxResult.message = String.Join(":", errMessage);
                    rAjaxResult.result = false;
                    return defJSON(rAjaxResult);
                }
            }
            catch (Exception ex)
            {
                rAjaxResult.result = false;
                rAjaxResult.message = ex.Message;
                return defJSON(rAjaxResult);
            }
        }
        public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByNameAsync(model.Email);
                if (user == null)
                {
                    ModelState.AddModelError("", "找不到用户。");
                    return View();
                }
                IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
                if (result.Succeeded)
                {
                    return RedirectToAction("ResetPasswordConfirmation", "Account");
                }
                else
                {
                    AddErrors(result);
                    return View();
                }
            }

            // 如果我们进行到这一步时某个地方出错,则重新显示表单
            return View(model);
        }
        public ActionResult HandleResetPassword(ResetPasswordViewModel model)
        {
            var membershipService = ApplicationContext.Current.Services.MemberService;

            if (!ModelState.IsValid)
            {
                return CurrentUmbracoPage();
            }

            //Get member from email
            var resetMember = membershipService.GetByEmail(model.EmailAddress);

            //Ensure we have that member
            if (resetMember != null)
            {
                //Get the querystring GUID
                var resetQueryString = Request.QueryString["resetGUID"];

                //Ensure we have a vlaue in QS
                if (!string.IsNullOrEmpty(resetQueryString))
                {
                    //See if the QS matches the value on the member property
                    if (resetMember.Properties["resetGUID"].Value.ToString() == resetQueryString)
                    {

                        //Got a match, now check to see if the 15min window hasnt expired
                        DateTime expiryTime = DateTime.ParseExact(resetQueryString, "ddMMyyyyHHmmssFFFF", null);

                        //Check the current time is less than the expiry time
                        DateTime currentTime = DateTime.Now;

                        //Check if date has NOT expired (been and gone)
                        if (currentTime.CompareTo(expiryTime) < 0)
                        {
                            //Got a match, we can allow user to update password
                            //resetMember.RawPasswordValue.Password = model.Password;
                            membershipService.SavePassword(resetMember, model.Password);

                            //Remove the resetGUID value
                            resetMember.Properties["resetGUID"].Value = string.Empty;

                            //Save the member
                            membershipService.Save(resetMember);

                            return Redirect("/login");
                        }
                        else
                        {
                            //ERROR: Reset GUID has expired
                            ModelState.AddModelError("ResetPasswordForm.", "Reset GUID has expired");
                            return CurrentUmbracoPage();
                        }
                    }
                    else
                    {
                        //ERROR: QS does not match what is stored on member property
                        //Invalid GUID
                        ModelState.AddModelError("ResetPasswordForm.", "Invalid GUID");
                        return CurrentUmbracoPage();
                    }
                }
                else
                {
                    //ERROR: No QS present
                    //Invalid GUID
                    ModelState.AddModelError("ResetPasswordForm.", "Invalid GUID");
                    return CurrentUmbracoPage();
                }
            }

            return RedirectToCurrentUmbracoPage();
        }
Esempio n. 59
0
        public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByNameAsync(model.Email);
                if (user == null)
                {
                    ModelState.AddModelError("", "No user found.");
                    return View();
                }
                IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
                if (result.Succeeded)
                {
                    return RedirectToAction("ResetPasswordConfirmation", "Account");
                }
                else
                {
                    AddErrors(result);
                    return View();
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
Esempio n. 60
0
        public ActionResult ResetPassword(int userId, string token)
        {
            var model = new ResetPasswordViewModel()
            {
                Token = token,
                UserId = userId
            };

            return token == null ? View("Error") : View(model);
        }