public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid) {

                // ChangePassword는 특정 실패 시나리오에서 false를 반환하지 않고
                // 예외를 throw합니다.
                bool changePasswordSucceeded;
                try {
                    MembershipUser currentUser = Membership.GetUser(User.Identity.Name, true /* userIsOnline */);
                    changePasswordSucceeded = currentUser.ChangePassword(model.OldPassword, model.NewPassword);
                }
                catch (Exception) {
                    changePasswordSucceeded = false;
                }

                if (changePasswordSucceeded) {
                    return RedirectToAction("ChangePasswordSuccess");
                }
                else {
                    ModelState.AddModelError("", "현재 암호가 정확하지 않거나 새 암호가 잘못되었습니다.");
                }
            }

            // 이 경우 오류가 발생한 것이므로 폼을 다시 표시하십시오.
            return View(model);
        }
Esempio n. 2
0
 public ActionResult ChangePassword(ChangePasswordModel model)
 {
     if (!ModelState.IsValid)
         return View(model);
     servicoAutorizacao.AlterarSenha(User.Identity.Name, model.OldPassword, model.NewPassword);
     return RedirectToAction("ChangePasswordSuccess");
 }
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid)
            {
                var status = _userService.ChangePassword(UserProfile.Current, model.OldPassword, model.NewPassword);

                switch (status)
                {
                    case ChangePasswordStatus.Success:

                        TempData.AddSuccessMessage(status.GetDescription());
                        return RedirectToAction("Index", "Home");

                    case ChangePasswordStatus.InvalidPassword:
                        ModelState.AddModelError(string.Empty, status.GetDescription());
                        break;
                    case ChangePasswordStatus.Failure:
                        ModelState.AddModelError(string.Empty, status.GetDescription());
                        break;
                }
            }

            ViewBag.PasswordLength = _membershipSetings.MinimumPasswordLength;
            return View(model);
        }
Esempio n. 4
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid)
            {

                // ChangePassword iniciará una excepción en lugar de
                // devolver false en determinados escenarios de error.
                bool changePasswordSucceeded;
                try
                {
                    MembershipUser currentUser = Membership.GetUser(User.Identity.Name, true /* userIsOnline */);
                    changePasswordSucceeded = currentUser.ChangePassword(EncodePassword(model.OldPassword), EncodePassword(model.NewPassword));
                }
                catch (Exception)
                {
                    changePasswordSucceeded = false;
                }

                if (changePasswordSucceeded)
                {
                    return RedirectToAction("ChangePasswordSuccess");
                }
                else
                {
                    ModelState.AddModelError("", "La contraseña actual es incorrecta o la nueva contraseña no es válida.");
                }
            }

            // Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
            return View(model);
        }
Esempio n. 5
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            bool changePasswordSucceeded;
            try
            {
                var currentUser = Membership.GetUser(User.Identity.Name, true /* userIsOnline */);
                Debug.Assert(currentUser != null, "currentUser != null");
                changePasswordSucceeded = currentUser.ChangePassword(model.OldPassword, model.NewPassword);
            }
            catch (Exception)
            {
                changePasswordSucceeded = false;
            }

            if (!changePasswordSucceeded)
            {
                ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");
                return View(model);
            }

            return RedirectToAction("ChangePasswordSuccess");
        }
Esempio n. 6
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid)
            {

                // ChangePassword will throw an exception rather
                // than return false in certain failure scenarios.
                bool changePasswordSucceeded;
                try
                {
                    MembershipUser currentUser = Membership.GetUser(User.Identity.Name, true /* userIsOnline */);
                    changePasswordSucceeded = currentUser.ChangePassword(model.OldPassword, model.NewPassword);
                }
                catch (Exception)
                {
                    changePasswordSucceeded = false;
                }

                if (changePasswordSucceeded)
                {
                    return RedirectToAction("ChangePasswordSuccess");
                }
                else
                {
                    ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
 public ActionResult ChangePassword()
 {
     var model = new ChangePasswordModel();
     model.Username = User.Identity.Name;
     var user = context.Accounts.FirstOrDefault(x => x.Username.Contains(model.Username));
     model.Email = user.Email;
     return View(model);
 }
        public void TestChangePassword()
        {
            string testUserName = "******";
            string testOldPassword = "******";
            string testNewPassword = "******";

            var changePasswordModel = new ChangePasswordModel
            {
                OldPassword = testOldPassword,
                NewPassword = testNewPassword
            };

            var accountController = new AccountController();

            //Stub HttpContext
            var stubHttpContext = new StubHttpContextBase();
            //Setup ControllerContext so AccountController will use our stubHttpContext
            accountController.ControllerContext = new ControllerContext(stubHttpContext,
                new RouteData(), accountController);

            //Stub IPrincipal
            var principal = new StubIPrincipal();
            principal.IdentityGet = () =>
            {
                var identity = new StubIIdentity { NameGet = () => testUserName };
                return identity;
            };
            stubHttpContext.UserGet = () => principal;

            RedirectToRouteResult redirectToRouteResult;
            //Scope the detours we're creating
            using (ShimsContext.Create())
            {
                ShimMembership.GetUserStringBoolean = (identityName, userIsOnline) =>
                {
                    Assert.AreEqual(testUserName, identityName);
                    Assert.AreEqual(true, userIsOnline);

                    var memberShipUser = new ShimMembershipUser();
                    //Sets up a detour for MemberShipUser.ChangePassword to our mocked implementation
                    memberShipUser.ChangePasswordStringString = (oldPassword, newPassword) =>
                    {
                        Assert.AreEqual(testOldPassword, oldPassword);
                        Assert.AreEqual(testNewPassword, newPassword);
                        return true;
                    };
                    return memberShipUser;
                };

                var actionResult = accountController.ChangePassword(changePasswordModel);
                Assert.IsInstanceOf(typeof(RedirectToRouteResult), actionResult);
                redirectToRouteResult = actionResult as RedirectToRouteResult;
            }
            Assert.NotNull(redirectToRouteResult);
            Assert.AreEqual("ChangePasswordSuccess", redirectToRouteResult.RouteValues["Action"]);
        }
Esempio n. 9
0
 public HttpResponseMessage ChangePassword(ChangePasswordModel model)
 {
     model.UserID = User.UserID;
     ActionOutput output = _userManager.ChangePassword(model);
     return Request.CreateResponse<ApiActionOutput>(new ApiActionOutput
     {
         Status = output.Status,
         Message = output.Message
     });
 }
Esempio n. 10
0
        public void ChangePassword(ChangePasswordModel changePasswordModel)
        {
            var db = GetDbContext();

            var user = GetCurrentUser();
            user.Password = EncryptPassword(changePasswordModel.NewPassword);

            db.SubmitChanges();

            SendEmail("admin@iudico", user.Email, "Iudico Notification", "Your passord has been changed.");
        }
Esempio n. 11
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid)
            {
                bool changePasswordSucceeded = true;
                try
                {
                    if (ModelState.IsValid && model.OldPassword != null)
                    {
                        int id = ((Session)Session["Session"]).UserID;
                        User oldUser = db.Users.Single(u => u.UserID == id);

                        string source = model.OldPassword;
                        using (MD5 md5Hash = MD5.Create())
                        {
                            Encryptor enc = new Encryptor();
                            string hash = enc.GetMd5Hash(md5Hash, source);
                            if (enc.VerifyMd5Hash(md5Hash, source, hash))
                            {
                                if (hash == oldUser.Password)
                                {
                                    source = model.NewPassword;
                                    hash = enc.GetMd5Hash(md5Hash, source);
                                    if (enc.VerifyMd5Hash(md5Hash, source, hash))
                                    {
                                        oldUser.Password = hash;
                                        db.Users.Attach(oldUser);
                                        db.ObjectStateManager.ChangeObjectState(oldUser, EntityState.Modified);
                                        db.SaveChanges();
                                        changePasswordSucceeded = true;
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception)
                {
                    changePasswordSucceeded = false;
                }

                if (changePasswordSucceeded)
                {
                    return RedirectToAction("ChangePasswordSuccess");
                }
                else
                {
                    ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
Esempio n. 12
0
        public ActionResult ChangePassword(int id)
        {
            User user = userService.GetUserById(id);

             ChangePasswordModel model = new ChangePasswordModel()
             {
            User = user
             };

             return this.View("ChangePassword", model);
        }
Esempio n. 13
0
        public ActionResult ChangePassword(string key)
        {
            var model = new ChangePasswordModel(key);

            if (model.Key != null)
            {
                return View(model);
            }

            return RedirectToAction("Login", new { returnUrl = "/" });
        }
        public void ShouldNotValidateModelWhenGetActionResult()
        {
            // arrange
            var invalidModel = new ChangePasswordModel {  };
            var controllerAction = new AccountController().Action(c => c.ChangePassword(invalidModel));
            var context = controllerAction.GetExecutionContext();

            // act
            controllerAction.GetActionResult(context);
            //assert
            context.ModelState.IsValid.Should().BeTrue();
        }
Esempio n. 15
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid) {
                if (MembershipService.ChangePassword(User.Identity.Name, model.OldPassword, model.NewPassword)) {
                    return RedirectToAction("ChangePasswordSuccess");
                } else {
                    ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
Esempio n. 16
0
 public ActionResult ChangePassword(string Email)
 {
     var user = userRepository.GetUserProfile(Email);
     ChangePasswordModel dv = null;
     if (user != null)
     {
         dv = new ChangePasswordModel();
         dv.Id = user.Id;
         dv.OldPassword = user.Password;
     }
     return GetView(WebConstants.View_ChangePassword, dv);
     //return GetView(WebConstants.View_ChangePasswordPartial, dv);
 }
        public RedirectToRouteResult ChangePassword(ChangePasswordModel model)
        {
            string status = "Fail";
            string message = "Sai mật khẩu. Vui lòng thử lại.";

            var user = context.Accounts.FirstOrDefault(x => x.Username == User.Identity.Name && x.Password == model.Password);
            if (user != null)
            {
                user.Password = model.NewPassword;
                context.SaveChanges();
                status = "Success";
                message = "Đổi mật khẩu thành công.";
            }
            TempData["Status"] = status;
            TempData["Message"] = message;
            return RedirectToAction("ChangePassword");
        }
Esempio n. 18
0
        public Task<HttpResponseMessage> ChangePassword(ChangePasswordModel model)
        {
            HttpResponseMessage response = new HttpResponseMessage();

            try
            {
                _service.ChangePassword(User.Identity.Name, model.Password, model.NewPassword, model.ConfirmNewPassword);
                response = Request.CreateErrorResponse(HttpStatusCode.OK, Messages.PasswordSuccessfulyChanges);
            }
            catch (Exception ex)
            {
                response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message);
            }

            var tsc = new TaskCompletionSource<HttpResponseMessage>();
            tsc.SetResult(response);
            return tsc.Task;
        }
Esempio n. 19
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid)
            {
                if (MembershipService.ChangePassword(User.Identity.Name, model.OldPassword, model.NewPassword))
                {
                    return RedirectToAction("ChangePasswordSuccess");
                }
                else
                {
                    ModelState.AddModelError("", "Неправильный текущий пароль или недопустимый новый пароль.");
                }
            }

            // Появление этого сообщения означает наличие ошибки; повторное отображение формы
            ViewData["PasswordLength"] = MembershipService.MinPasswordLength;
            return View(model);
        }
Esempio n. 20
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid)
            {
                if (MembershipService.ChangePassword(User.Identity.Name, model.OldPassword, model.NewPassword))
                {
                    return RedirectToAction("ChangePasswordSuccess");
                }
                else
                {
                    ModelState.AddModelError("", "当前密码不正确或新密码无效。");
                }
            }

            // 如果我们进行到这一步时某个地方出错,则重新显示表单
            ViewData["PasswordLength"] = MembershipService.MinPasswordLength;
            return View(model);
        }
Esempio n. 21
0
 public ActionResult ChangePassword(ChangePasswordModel model)
 {
     if (ModelState.IsValid)
     {
         if (MembershipService.ChangePassword(User.Identity.Name, model.OldPassword, model.NewPassword))
         {
             ViewBag.Success = "密码修改成功。";
             return View();
         }
         else
         {
             ModelState.AddModelError("", "当前密码不正确或新密码无效。");
         }
     }
     // 如果我们进行到这一步时某个地方出错,则重新显示表单
     ViewBag.PasswordLength = MembershipService.MinPasswordLength;
     return View(model);
 }
Esempio n. 22
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (!User.IsInRole("admin"))
            {
                return RedirectToAction("UserProfile", "UserPages", new { UserName = User.Identity.Name });
            }
            if (ModelState.IsValid)
            {

                // ChangePassword will throw an exception rather
                // than return false in certain failure scenarios.
                string OldPassword;
                string NewPassword;
                bool changePasswordSucceeded;
                try
                {
                    // Get user
                    MembershipUser currentUser = Membership.GetUser(model.UserName);

                    // Get old password
                    OldPassword = currentUser.GetPassword();

                    // Get new password
                    NewPassword = model.NewPassword;
                    changePasswordSucceeded = currentUser.ChangePassword(OldPassword, NewPassword);
                }
                catch (Exception)
                {
                    changePasswordSucceeded = false;
                }

                if (changePasswordSucceeded)
                {
                    return RedirectToAction("ChangePasswordSuccess");
                }
                else
                {
                    ModelState.AddModelError("", "OldPass:"******"NewPass:"******"User:" + model.UserName);
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
        public void AccountController_ChangePassword_Post_ReturnsRedirectOnSuccess()
        {
            // Arrange
            AccountController controller = GetAccountController();
            ChangePasswordModel model = new ChangePasswordModel()
            {
                OldPassword = "******",
                NewPassword = "******",
                ConfirmPassword = "******"
            };

            // Act
            ActionResult result = controller.ChangePassword(model);

            // Assert
            Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
            RedirectToRouteResult redirectResult = (RedirectToRouteResult)result;
            Assert.AreEqual("ChangePasswordSuccess", redirectResult.RouteValues["action"]);
        }
Esempio n. 24
0
 ActionOutput IUserManager.ChangePassword(ChangePasswordModel model)
 {
     byte[] oldPassword = Utility.GetEncryptedValue(model.OldPassword);
     byte[] newPassword = Utility.GetEncryptedValue(model.NewPassword);
     User user = Context.Users.Where(m => m.UserID == model.UserID && m.Password == oldPassword).FirstOrDefault();
     if (user == null)
         return new ActionOutput
         {
             Status = ActionStatus.Error,
             Message = "Old password is incorrect."
         };
     user.Password = newPassword;
     SaveChanges();
     return new ActionOutput
     {
         Status = ActionStatus.Successfull,
         Message = "Password has been changed."
     };
 }
Esempio n. 25
0
 public ActionResult ChangePassword(ChangePasswordModel model)
 {
     if (ModelState.IsValid)
     {
         if (dbContext.Users.ChangePassword(User.Identity.Name, model.OldPassword, model.NewPassword))
         {
             //var _event = new PasswordChangedEvent(User.Identity.Name, model.OldPassword, model.NewPassword);
             //_event.Raise(HttpContext);
             this.Trigger("PasswordChanged", model);
             //var app = App.Get();
             //var user = app.Users[User.Identity.Name];
             //App.Get().SendMail(SystemMails.PasswodChanged, model, user.Email);
         }
         else
         {
             ModelState.AddModelError("", Resources.Validations.Password_Incorrect);
         }
     }
     return PartialView(model);
 }
        public void ChangePassword_Post_ReturnsViewIfChangePasswordFails()
        {
            // 排列
            AccountController controller = GetAccountController();
            ChangePasswordModel model = new ChangePasswordModel()
            {
                OldPassword = "******",
                NewPassword = "******",
                ConfirmPassword = "******"
            };

            // 操作
            ActionResult result = controller.ChangePassword(model);

            // 断言
            Assert.IsInstanceOfType(result, typeof(ViewResult));
            ViewResult viewResult = (ViewResult)result;
            Assert.AreEqual(model, viewResult.ViewData.Model);
            Assert.AreEqual("当前密码不正确或新密码无效。", controller.ModelState[""].Errors[0].ErrorMessage);
            Assert.AreEqual(10, viewResult.ViewData["PasswordLength"]);
        }
        public void AccountController_ChangePassword_Post_ReturnsViewIfChangePasswordFails()
        {
            // Arrange
            AccountController controller = GetAccountController();
            ChangePasswordModel model = new ChangePasswordModel()
            {
                OldPassword = "******",
                NewPassword = "******",
                ConfirmPassword = "******"
            };

            // Act
            ActionResult result = controller.ChangePassword(model);

            // Assert
            Assert.IsInstanceOfType(result, typeof(ViewResult));
            ViewResult viewResult = (ViewResult)result;
            Assert.AreEqual(model, viewResult.ViewData.Model);
            Assert.AreEqual("The current password is incorrect or the new password is invalid.", controller.ModelState[""].Errors[0].ErrorMessage);
            Assert.AreEqual(10, viewResult.ViewData["PasswordLength"]);
        }
 public ActionResult ChangePassword(ChangePasswordModel model)
 {
     if (ModelState.IsValid)
     {
         try
         {
             if (this._userService.ChangePassword(User.Identity.Name, model.OldPassword, model.NewPassword))
             {
                 return View("ChangePasswordSuccess");
             }
             else
             {
                 ModelState.AddModelError("", "Error changing password");
             }
         }
         catch (ValidationException ex)
         {
             ModelState.AddModelError("", ex.Message);
         }
     }
     return View(model);
 }
Esempio n. 29
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid)
            {
                var user = userRepository.GetById(model.Id);

                string hPassword = Encryptor.MD5Hash(model.OldPassword);
                if (hPassword.Equals(user.Password))
                {
                    var result = userRepository.ChangePassword(model.Id, model.NewPassword);
                    if (result)
                        ModelState.AddModelError("Success", "The password is changed successful.");
                }
                else
                {
                    ModelState.AddModelError("Error", "The current password did not match with old password.");
                }
            }

            return GetView(WebConstants.View_ChangePassword, model);
            //return GetView(WebConstants.View_ChangePasswordPartial, model);
        }
Esempio n. 30
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            var user = WebSecurity.GetUserFromKey(model.Key);
            if (user == null)
            {
                return RedirectToAction("Login");
            }

            var u = Membership.GetUser(user.Username);
            if (u == null)
            {
                return RedirectToAction("Login");
            }

            WebSecurity.ChangePassword(u.UserName, model.Password);
            WebSecurity.ClearResetKey(u.UserName);

            return RedirectToAction("Login");
        }
Esempio n. 31
0
        public async Task <IActionResult> Post([FromBody] ChangePasswordModel model)
        {
            // Validate the request
            if (model == null)
            {
                return(BadRequest(ApiResult.InvalidRequest()));
            }

            var result = new ApiResult();

            // Validate the model
            if (ModelState.IsValid == false)
            {
                result.AddModelStateErrors(ModelState);

                return(BadRequest(result));
            }

            // Validate the Captcha
            try
            {
                // Sonar-Codacy suggested ConfigureAwait
                if (await ValidateRecaptcha(model.Recaptcha).ConfigureAwait(false) == false)
                {
                    result.Errors.Add(new ApiErrorItem {
                        ErrorCode = ApiErrorCode.InvalidCaptcha
                    });
                }
            }
            catch (Exception ex)
            {
                result.Errors.Add(new ApiErrorItem
                {
                    ErrorCode = ApiErrorCode.Generic,
                    Message   = ex.Message
                });
            }

            if (result.HasErrors)
            {
                return(BadRequest(result));
            }

            var currentUsername = GetUserName(model, result);

            if (result.HasErrors)
            {
                return(BadRequest(result));
            }

            var resultPasswordChange = _passwordChangeProvider.PerformPasswordChange(currentUsername, model.CurrentPassword, model.NewPassword);

            if (resultPasswordChange != null)
            {
                result.Errors.Add(resultPasswordChange);
            }

            if (result.HasErrors)
            {
                Response.StatusCode = (int)HttpStatusCode.BadRequest;
            }

            return(Json(result));
        }
Esempio n. 32
0
        public ActionResult ChangePassword()
        {
            var model = new ChangePasswordModel();

            return(View(model));
        }
Esempio n. 33
0
        /// <summary>
        /// To check and update the password..
        /// </summary>
        /// <param name="users"></param>
        /// <returns></returns>
        public DataTable ChangePassword(ChangePasswordModel ChangePasswordModel)
        {
            var DbManager = new DBManager("DBConnection");

            return(DbManager.GetDataTable(_StoredProcedures.UpdateUserPassword_SP, CommandType.StoredProcedure, _instanceRepository.AddParasUpdatePassword(ChangePasswordModel)));
        }
 public async Task <IHttpActionResult> ChangePassword(ChangePasswordModel model)
 {
     return(await RunTask(() => AccountManager.ChangePasswordAsync(User, model)));
 }
Esempio n. 35
0
 public ActionResult ChangePassword(ChangePasswordModel model)
 {
     //DependencyResolver.SetResolver();
     return(View(model));
 }
 public async Task <IActionResult> ChangePassword(Guid id, ChangePasswordModel changePasswordModel)
 {
     return(Ok(ApiResult <BaseResponseModel> .Success(
                   await _userService.ChangePasswordAsync(id, changePasswordModel))));
 }
 public ActionResult ChangePassword(ChangePasswordModel changePassword)
 {
     changePassword.Password = GetMD5(changePassword.Password);
     user.changepassword(changePassword);
     return(View());
 }
Esempio n. 38
0
        public async Task <IHttpActionResult> ChangePassword(ChangePasswordModel model)
        {
            var result = await _authRepo.ChangePassword(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);

            return(Ok());
        }
Esempio n. 39
0
 public ActionResult ChangePassword(ChangePasswordModel model)
 {
     ModelState.Clear();
     return(View(model));
 }
 public ChangePasswordPresenter(params object[] param) : base(param)
 {
     model = new ChangePasswordModel();
 }
Esempio n. 41
0
        public async Task <Boolean> ChangePassword(ChangePasswordModel model)
        {
            var changed = await userRepository.ChangePassword(model);

            return(changed);
        }
Esempio n. 42
0
 public ActionResult ChangePassword(ChangePasswordModel model)
 {
     return(View());
 }
Esempio n. 43
0
 public async Task <ActionResult <bool> > ChangePassword([FromBody] ChangePasswordModel model)
 {
     return(await this.ExecuteWithOkResponse(async() => await _profileService.ChangePassword(model)));
 }
        //method to change the password
        public async Task <IdentityResult> ChangePasswordAsync(ChangePasswordModel changePassword)
        {
            var user = await _userManager.FindByIdAsync(_userService.GetUserId());

            return(await _userManager.ChangePasswordAsync(user, changePassword.CurrentPassword, changePassword.NewPassword));
        }
Esempio n. 45
0
 public async Task <AjaxModel <NTModel> > ChangePassword([FromBody] ChangePasswordModel model)
 {
     return(await AjaxHelper.SaveAsync(m => domain.ChangePassword(model), SecurityMessages.ChangePasswordSuccess));
 }
Esempio n. 46
0
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (model.NewPassword.IsNullOrWhiteSpace())
            {
                throw new ArgumentException($"新密码不能为 Null 或空白", nameof(model.NewPassword));
            }
            if (model.NewPassword2.IsNullOrWhiteSpace())
            {
                throw new ArgumentException($"确认密码不能为 Null 或空白", nameof(model.NewPassword2));
            }
            if (model.NewPassword != model.NewPassword2)
            {
                throw new ArgumentException($"两次输入密码不一致", nameof(model.NewPassword));
            }

            var set = Setting.Current;

            if (model.NewPassword.Length < set.MinPasswordLength)
            {
                throw new ArgumentException($"最短密码要求{set.MinPasswordLength}位", nameof(model.NewPassword));
            }

            // SSO 登录不需要知道原密码就可以修改,原则上更相信外方,同时也避免了直接第三方登录没有设置密码的尴尬
            var ssoName        = Session["Cube_Sso"] as String;
            var requireOldPass = ssoName.IsNullOrEmpty();

            if (requireOldPass)
            {
                if (model.OldPassword.IsNullOrWhiteSpace())
                {
                    throw new ArgumentException($"原密码不能为 Null 或空白", nameof(model.OldPassword));
                }
                if (model.NewPassword == model.OldPassword)
                {
                    throw new ArgumentException($"修改密码不能与原密码一致", nameof(model.NewPassword));
                }
            }

            var cur = ManageProvider.User;

            if (cur == null)
            {
                return(RedirectToAction("Login"));
            }

            var user = XCode.Membership.User.FindByKeyForEdit(cur.ID);

            var oldpass2 = model.OldPassword.MD5();

            if (requireOldPass && !user.Password.EqualIgnoreCase(oldpass2))
            {
                throw new Exception("密码错误");
            }

            // 修改密码
            user.Password = model.NewPassword;
            user.Update();

            ViewBag.StatusMessage = "修改成功!";

            if (IsJsonRequest)
            {
                return(Ok(ViewBag.StatusMessage));
            }

            return(ChangePassword());
        }
Esempio n. 47
0
        public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordModel changePasswordModel, CancellationToken cancellationToken)
        {
            var status = await _authService.ChangePassword(changePasswordModel, cancellationToken);

            return(Ok(status));
        }
Esempio n. 48
0
        public System.Web.Http.Results.OkNegotiatedContentResult <ResponseModel> ChangePassword([FromBody] ChangePasswordModel changePasswordModel)
        {
            try
            {
                SaltedHash    SH       = new SaltedHash();
                string        strHash  = "";
                string        strSalt  = "";
                byte[]        hash     = null;
                byte[]        salt     = null;
                ResponseModel response = new ResponseModel();

                // See if this is a temporary password
                if (IsTemporaryPassword(changePasswordModel) == true)
                {
                    // Dont check for a valid login
                }
                else if (IsValidLogin(changePasswordModel.LoginId, changePasswordModel.OldPassword) == false)
                {
                    response.Code    = "error";
                    response.Message = "Invalid Login or Password";
                    return(Ok(content: response));
                }

                SH.GetHashAndSaltString(changePasswordModel.NewPassword, out strHash, out strSalt);
                System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
                hash = encoding.GetBytes(strHash);
                salt = encoding.GetBytes(strSalt);
                SqlConnection myConnection = new SqlConnection();
                myConnection.ConnectionString = System.Configuration.ConfigurationManager.AppSettings["DBConnection"];
                SqlCommand sqlCmd = new SqlCommand();
                sqlCmd.CommandText = "spChangePassword";
                sqlCmd.CommandType = CommandType.StoredProcedure;
                sqlCmd.Connection  = myConnection;

                SqlParameter parameter = new SqlParameter();
                parameter.ParameterName = "@Login_Id";
                parameter.SqlDbType     = SqlDbType.VarChar;
                parameter.Direction     = ParameterDirection.Input;
                parameter.Size          = 50;
                parameter.Value         = changePasswordModel.LoginId;
                sqlCmd.Parameters.Add(parameter);

                parameter = new SqlParameter();
                parameter.ParameterName = "@Hash";
                parameter.SqlDbType     = SqlDbType.VarBinary;
                parameter.Direction     = ParameterDirection.Input;
                parameter.Size          = 250;
                parameter.Value         = hash;
                sqlCmd.Parameters.Add(parameter);

                parameter = new SqlParameter();
                parameter.ParameterName = "@Salt";
                parameter.SqlDbType     = SqlDbType.VarBinary;
                parameter.Direction     = ParameterDirection.Input;
                parameter.Size          = 250;
                parameter.Value         = salt;
                sqlCmd.Parameters.Add(parameter);

                parameter = new SqlParameter();
                parameter.ParameterName = "@Results";
                parameter.SqlDbType     = SqlDbType.VarChar;
                parameter.Size          = 50;
                parameter.Direction     = ParameterDirection.Output;
                sqlCmd.Parameters.Add(parameter);

                myConnection.Open();
                sqlCmd.ExecuteNonQuery();

                if (parameter.Value.ToString().Equals("0"))
                {
                    response.Code    = "success";
                    response.Message = "Your Password Has Been Changed Successfully";
                }
                else
                {
                    response.Code    = "error";
                    response.Message = "Invalid Login or Password";
                }
                myConnection.Close();

                return(Ok(content: response));
            }
            catch (Exception ex)
            {
                ExceptionModel.SaveException(ex.Message, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.ToString(), System.Reflection.MethodInfo.GetCurrentMethod().Name);
                return(null);
            }
        }
Esempio n. 49
0
 public static bool ChangePassword(ChangePasswordModel model)
 {
     return(true);
 }
Esempio n. 50
0
 public Task ChangePassword(ChangePasswordModel model)
 {
     throw new System.NotImplementedException();
 }
Esempio n. 51
0
        public async Task <IdentityResult> ChangePassword(ChangePasswordModel model)
        {
            var result = await _userManager.ChangePasswordAsync(model.UserID, model.CurrentPassword, model.NewPassword);

            return(result);
        }
Esempio n. 52
0
        public async Task <IActionResult> Post([FromBody] ChangePasswordModel model)
        {
            _logger.Information("START PasswordController.Post: ");
            // Validate the request
            if (model == null)
            {
                _logger.Warning("Null model");

                return(BadRequest(ApiResult.InvalidRequest()));
            }

            if (model.NewPassword != model.NewPasswordVerify)
            {
                _logger.Warning("Invalid model, passwords don't match");

                return(BadRequest(ApiResult.InvalidRequest()));
            }

            // Validate the model
            if (ModelState.IsValid == false)
            {
                _logger.Warning("Invalid model, validation failed");

                return(BadRequest(ApiResult.FromModelStateErrors(ModelState)));
            }

            //BAONX
            //            // Validate the Captcha
            //            try
            //            {
            //                if (await ValidateRecaptcha(model.ReCaptcha).ConfigureAwait(false) == false)
            //                    throw new InvalidOperationException("Invalid ReCaptcha response");
            //            }
            //#pragma warning disable CA1031 // Do not catch general exception types
            //            catch (Exception ex)
            //#pragma warning restore CA1031 // Do not catch general exception types
            //            {
            //                _logger.Warning(ex, "Invalid ReCaptcha");
            //                return BadRequest(ApiResult.InvalidCaptcha());
            //            }

            var result = new ApiResult();

            try
            {
                //BAONX
                //if (_options.MinimumDistance > 0 &&
                //    _passwordChangeProvider.MeasureNewPasswordDistance(model.CurrentPassword, model.NewPassword) < _options.MinimumDistance)
                //{
                //    result.Errors.Add(new ApiErrorItem(ApiErrorCode.MinimumDistance));
                //    return BadRequest(result);
                //}

                //if (_options.MinimumScore > 0 && Zxcvbn.Core.EvaluatePassword(model.NewPassword).Score < _options.MinimumScore)
                //{
                //    result.Errors.Add(new ApiErrorItem(ApiErrorCode.MinimumScore));
                //    return BadRequest(result);
                //}

                var resultPasswordChange = _passwordChangeProvider.PerformPasswordChange(
                    model.Username,
                    model.CurrentPassword,
                    model.NewPassword);

                if (resultPasswordChange == null)
                {
                    return(Json(result));
                }

                result.Errors.Add(resultPasswordChange);
            }
#pragma warning disable CA1031 // Do not catch general exception types
            catch (Exception ex)
#pragma warning restore CA1031 // Do not catch general exception types
            {
                _logger.Error(ex, "Failed to update password");

                result.Errors.Add(new ApiErrorItem(ApiErrorCode.Generic, ex.Message));
            }

            _logger.Warning(Json(result).ToString());
            return(BadRequest(result));
        }
        /// <summary>
        /// Prepare the change password model
        /// </summary>
        /// <returns>Change password model</returns>
        public virtual ChangePasswordModel PrepareChangePasswordModel()
        {
            var model = new ChangePasswordModel();

            return(model);
        }
Esempio n. 54
0
        public ActionResult ChangePassword(string option, string username)
        {
            var model = new ChangePasswordModel(option, username);

            return(View(model));
        }
Esempio n. 55
0
        public async Task <IHttpActionResult> ChangePassword(ChangePasswordModel model)
        {
            var result = await userManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);

            return(Ok(result));
        }
 public Task <bool> ChangePassword(int userId, ChangePasswordModel model)
 {
     throw new NotImplementedException();
 }
Esempio n. 57
0
        public async Task <IdentityResult> ChangePassword(ChangePasswordModel model)
        {
            var user = await db.Users.FindUser(model.UserName);

            return(await db.Users.ChangePassword(user.Id, model.OldPassword, model.NewPassword));
        }
Esempio n. 58
0
 public async Task <ChangePasswordModel> ChangePasswordAsync(ChangePasswordModel model)
 {
     return(await _apiHelper.PostAsync(model, "api/Account/Manage/ChangePassword"));
 }
Esempio n. 59
0
        public ResponseModel ChangePassword(ChangePasswordModel usermodel)
        {
            #region validation
            if (usermodel == null || string.IsNullOrEmpty(usermodel.NewPassword) || string.IsNullOrEmpty(usermodel.UserId))
            {
                return(new ResponseModel
                {
                    Success = false,
                    Messages = new List <string> {
                        "Data not mapped"
                    },
                    Data = usermodel
                });
            }

            if (usermodel.NewPassword != usermodel.ConfirmNewPassword)
            {
                return(new ResponseModel
                {
                    Success = false,
                    Messages = new List <string> {
                        "Password does not match"
                    },
                    Data = usermodel
                });
            }
            #endregion

            ApplicationUser user = UserManager.FindById(usermodel.UserId);
            if (user == null)
            {
                return(new ResponseModel
                {
                    Success = false,
                    Messages = new List <string> {
                        "User not found"
                    },
                    Data = usermodel
                });
            }
            user.PasswordHash = UserManager.PasswordHasher.HashPassword(usermodel.NewPassword);
            var result = UserManager.Update(user);
            if (!result.Succeeded)
            {
                return(new ResponseModel
                {
                    Success = false,
                    Messages = new List <string> {
                        "Failed to update password"
                    },
                    Data = usermodel
                });
            }
            return(new ResponseModel
            {
                Success = true,
                Messages = new List <string> {
                    "Password updated"
                },
                Data = usermodel
            });
        }
Esempio n. 60
0
        public async Task <IActionResult> Post([FromBody] ChangePasswordModel model)
        {
            // Validate the request
            if (model == null)
            {
                _logger.LogWarning("Null model");

                return(BadRequest(ApiResult.InvalidRequest()));
            }

            if (model.NewPassword != model.NewPasswordVerify)
            {
                _logger.LogWarning("Invalid model, passwords don't match");

                return(BadRequest(ApiResult.InvalidRequest()));
            }

            // Validate the model
            if (ModelState.IsValid == false)
            {
                _logger.LogWarning("Invalid model, validation failed");

                return(BadRequest(ApiResult.FromModelStateErrors(ModelState)));
            }

            // Validate the Captcha
            try
            {
                if (await ValidateRecaptcha(model.Recaptcha).ConfigureAwait(false) == false)
                {
                    throw new InvalidOperationException("Invalid Recaptcha response");
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Invalid Recaptcha");
                return(BadRequest(ApiResult.InvalidCaptcha()));
            }

            var result = new ApiResult();

            try
            {
                if (_options.MinimumDistance > 0 &&
                    _passwordChangeProvider.MeasureNewPasswordDistance(model.CurrentPassword, model.NewPassword) < _options.MinimumDistance)
                {
                    result.Errors.Add(new ApiErrorItem(ApiErrorCode.MinimumDistance));
                    return(BadRequest(result));
                }

                if (_options.MinimumScore > 0 && Core.EvaluatePassword(model.NewPassword).Score < _options.MinimumScore)
                {
                    result.Errors.Add(new ApiErrorItem(ApiErrorCode.MinimumScore));
                    return(BadRequest(result));
                }

                var resultPasswordChange = _passwordChangeProvider.PerformPasswordChange(
                    model.Username,
                    model.CurrentPassword,
                    model.NewPassword);

                if (resultPasswordChange == null)
                {
                    return(Json(result));
                }

                result.Errors.Add(resultPasswordChange);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to update password");

                result.Errors.Add(new ApiErrorItem(ApiErrorCode.Generic, ex.Message));
            }

            return(BadRequest(result));
        }