Example #1
0
        public virtual ActionResult ChangePassword(ChangePasswordViewModel 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 RedirectToAction("ChangePassword");
        }
        public ActionResult ChangePassword(ChangePasswordViewModel model)
        {
            if (model == null) throw new ArgumentNullException("model");

            if (ModelState.IsValid)
            {
                bool changePasswordSucceeded;
                try
                {
                    changePasswordSucceeded = WebSecurity.ChangePassword(User.Identity.Name, model.OldPassword,
                                                                         model.NewPassword);
                }
                catch (Exception)
                {
                    changePasswordSucceeded = false;
                }

                if (changePasswordSucceeded)
                {
                    TempData["SuccessMessage"] = "Пароль успешно изменен";
                }
                else
                {
                    ModelState.AddModelError("", "Неправильный текущий пароль или недопустимый новый пароль.");
                }
            }
            return View(model);
        }
        public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (!this.ModelState.IsValid)
            {
                return this.View(model);
            }

            var result = await this.UserManager
                .ChangePasswordAsync(
                User.Identity.GetUserId(), 
                model.OldPassword, 
                model.NewPassword);

            if (result.Succeeded)
            {
                var user = await this.UserManager.FindByIdAsync(User.Identity.GetUserId());
                if (user != null)
                {
                    await this.SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                }

                return this.RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess });
            }

            this.AddErrors(result);
            return this.View(model);
        }
Example #4
0
        public ActionResult ChangePassword(ChangePasswordViewModel model)
        {
            if (this.ModelState.IsValid && this.authentication.ChangePassword(this.authentication.CurrentUserName, model.OldPassword, model.NewPassword))
            {
                return this.RedirectToAction("ChangePassword", new { saveSuccessful = true });
            }

            this.ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");

            return this.View(model);
        }
        public void ChangePasswordAction_WithValidValuesReturnsRedirectToRoute()
        {
            // Arrange
            var controller = CreateAccountController();
            var changePasswordView = new ChangePasswordViewModel { UserName = "******", OldPassword = "******", NewPassword = "******" };

            // Act
            var result = controller.ChangePassword(changePasswordView);

            // Assert
            Assert.IsInstanceOf<RedirectToRouteResult>(result, "RedirectToRouteResult not returned.");
        }
        public void ChangePasswordAction_ReturnsViewIfFails()
        {
            // Arrange
            var controller = CreateAccountController();
            var changePasswordView = new ChangePasswordViewModel { UserName = "******", OldPassword = "******", NewPassword = "******" };

            // Act
            var result = controller.ChangePassword(changePasswordView);
            var viewResult = (ViewResult)result;

            // Assert
            Assert.IsInstanceOf<ViewResult>(result, "ViewResult not returned.");
            Assert.AreSame(changePasswordView, viewResult.ViewData.Model, "User and Model are not the same");
            Assert.AreEqual(false, viewResult.ViewData.ModelState.IsValid);
        }
        public void ChangePasswordAction_WithValidValuesUpdatesPassword()
        {
            // Arrange
            var controller = CreateAccountController();

            var user = new LoginViewModel { UserName = "******", Password = "******" };
            var changePasswordView = new ChangePasswordViewModel { UserName = "******", OldPassword = "******", NewPassword = "******" };

            // Act
            var result = controller.ChangePassword(changePasswordView);

            // Assert
            //Assert.IsInstanceOf<RedirectToRouteResult>(result, "Redirect to route not returned.");
            //Assert.AreEqual("Customers", redirectresult.RouteValues["controller"]);
            //Assert.AreEqual("Index", redirectresult.RouteValues["action"]);
        }
        public void ChangePasswordAction_ReturnsViewIfInvalidModelState()
        {
            // Arrange
            var controller = CreateAccountController();
            var changePasswordView = new ChangePasswordViewModel { UserName = "******", OldPassword = "******", NewPassword = "******" };
            controller.ModelState.AddModelError("*", "Invalid model state.");

            // Act
            var result = controller.ChangePassword(changePasswordView);

            // Assert
            Assert.IsInstanceOf<ViewResult>(result, "ViewResult not returned.");

            var viewResult = (ViewResult)result;
            Assert.AreSame(changePasswordView, viewResult.ViewData.Model, "User and Model are not the same");
        }
Example #9
0
        public async Task<IActionResult> Password(ChangePasswordViewModel viewModel)
        {
            if (!ModelState.IsValid)
                return RedirectToAction("Password");

            return await _userService.SetNewPasswordAsync(UserId, viewModel.ActualPassword, viewModel.NewPassword)
                .Execute(
                    onSuccess: () =>
                    {
                        Notify(FlashNotificationType.Success, "Password has been changed.");
                        return RedirectToAction("Index");
                    },
                    onFailure: ex =>
                    {
                        Notify(FlashNotificationType.Error, ex.Message);
                        return RedirectToAction("Password");
                    });
        }
        public ActionResult ChangePassword(ChangePasswordViewModel model)
        {
            model.UserName = User.Identity.Name;

            if (ModelState.IsValid)
            {
                if (MembershipService.ChangePassword(model.UserName, model.OldPassword, model.NewPassword))
                {
                    return RedirectToAction("ChangePasswordSuccess");
                }

                ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");
            }

            // If we got this far, something failed, redisplay form
            ViewBag.PasswordLength = MembershipService.MinPasswordLength;
            return View(model);
        }
        public JsonResult ChangePassword(ChangePasswordViewModel changePasswordView)
        {
            if (!ModelState.IsValid)
            {
                return Json(new { Success = false, Message = Resources.ValidationFailed });
            }

            var command = new ChangePasswordCommand(UserInfo.Id, changePasswordView.CurrentPassword, changePasswordView.NewPassword);
            var result = ExecuteCommand(command);

            if (result)
            {
                TempData[ViewDataKeys.Message] = new SuccessMessage(Resources.PasswordChangeSuccess);

                return Json(new { Success = true });
            }
            else
            {
                return Json(new { Success = false, Message = Resources.IncorrectCurrentPassword });
            }
        }
        public async Task<ActionResult> ChangePassword(ChangePasswordViewModel changePasswordViewModel)
        {
            if (!ModelState.IsValid)
                return View(changePasswordViewModel);

            var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId<int>(), changePasswordViewModel.CurrentPassword, changePasswordViewModel.NewPassword);
            if (result.Succeeded)
            {
                var user = await UserManager.FindByIdAsync(User.Identity.GetUserId<int>());
                if (user != null)
                {
                    AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
                    await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                    TempData["Message"] = ActionMessage.ChangePasswordSuccess;
                }
                return RedirectToAction("changepassword", "action");
            }
            AddErrors(result);

            return View(changePasswordViewModel);
        }
Example #13
0
        public async Task <IActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var user = await GetCurrentUserAsync();

            if (user != null)
            {
                var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);

                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent : false);

                    _logger.LogInformation(3, "User changed their password successfully.");
                    return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.ChangePasswordSuccess }));
                }
                AddErrors(result);
                return(View(model));
            }
            return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error }));
        }
Example #14
0
 public async Task <ApiResponseDto> AdminChangePassword(ChangePasswordViewModel parameters)
 {
     return(await _accountApiClient.AdminChangePassword(parameters));
 }
Example #15
0
        public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            var user = await GetCurrentUser();
            if (user != null)
            {
                var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    return RedirectToAction(nameof(Microsoft.EntityFrameworkCore.Metadata.Internal.Index), new { Message = ManageMessageId.ChangePasswordSuccess });
                }

                AddErrorsToModelState(result);

                return View(model);
            }

            return RedirectToAction(nameof(Microsoft.EntityFrameworkCore.Metadata.Internal.Index), new { Message = ManageMessageId.Error });
        }
        public ActionResult ChangePassword()
        {
            var vm = new ChangePasswordViewModel();

            return(View(vm));
        }
 public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model)
 {
     if (!ModelState.IsValid)
     {
         return View(model);
     }
     var user = await GetCurrentUserAsync();
     if (user != null)
     {
         var result = await UserManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
         if (result.Succeeded)
         {
             await SignInManager.SignInAsync(user, isPersistent: false);
             return RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess });
         }
         AddErrors(result);
         return View(model);
     }
     return RedirectToAction("Index", new { Message = ManageMessageId.Error });
 }
        private void OnSelectedMenuItem()
        {
            if (SelectedMenuItem == MenuResources.ChangePassword)
            {
                if (ChangePasswordViewModel == null)
                    ChangePasswordViewModel = new ChangePasswordViewModel(this.Messenger, this.UserLogin)
                        {
                            ParentViewModel = this
                        };

                DetailSectionViewModel = ChangePasswordViewModel;
                return;
            }
        }
        // GET: /Manage/ChangePassword
        public ActionResult ChangePassword()
        {
            ChangePasswordViewModel model = new ChangePasswordViewModel();

            return this.View(model);
        }
Example #20
0
 public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model)
 {
     return(View());
 }
 public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model)
 {
     if (!ModelState.IsValid)
     {
         return View(model);
     }
     IdentityResult result = await _userManager.ChangePasswordAsync(User.Identity.GetUserId2<ObjectId>()
         , model.OldPassword, model.NewPassword);
     if (result.Succeeded)
     {
         var user = await _userManager.FindByIdAsync(User.Identity.GetUserId2<ObjectId>());
         if (user != null)
         {
             await SignInAsync(user, isPersistent: false);
         }
         return RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess });
     }
     AddErrors(result);
     return View(model);
 }
Example #22
0
        public async Task <IActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                UserIdent user = await _userManager.FindByIdAsync(model.Id);

                if (user != null)
                {
                    var _passwordValidator =
                        HttpContext.RequestServices.GetService(typeof(IPasswordValidator <UserIdent>)) as
                        IPasswordValidator <UserIdent>;
                    var _passwordHasher =
                        HttpContext.RequestServices.GetService(typeof(IPasswordHasher <UserIdent>)) as
                        IPasswordHasher <UserIdent>;

                    IdentityResult result =
                        await _passwordValidator.ValidateAsync(_userManager, user, model.NewPassword);

                    if (result.Succeeded)
                    {
                        user.PasswordHash = _passwordHasher.HashPassword(user, model.NewPassword);
                        await _userManager.UpdateAsync(user);

                        return(RedirectToAction("Index"));
                    }
                    else
                    {
                        foreach (var error in result.Errors)
                        {
                            ModelState.AddModelError(string.Empty, error.Description);
                        }
                    }
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Пользователь ненайден");
                }
            }

            return(View(model));

            //второй вариант

            //if (ModelState.IsValid)
            //{
            //    User user = await _userManager.FindByIdAsync(model.Id);
            //    if (user != null)
            //    {
            //        IdentityResult result =
            //            await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
            //        if (result.Succeeded)
            //        {
            //            return RedirectToAction("Index");
            //        }
            //        else
            //        {
            //            foreach (var error in result.Errors)
            //            {
            //                ModelState.AddModelError(string.Empty, error.Description);
            //            }
            //        }
            //    }
            //    else
            //    {
            //        ModelState.AddModelError(string.Empty, "Пользователь не найден");
            //    }
            //}
            //return View(model);
        }
 public ChangePassword()
 {
     InitializeComponent();
     this.BindingContext = ViewModel = new ChangePasswordViewModel();
 }
Example #24
0
        public ActionResult EditUserPasswordPost(ChangePasswordViewModel model)
        {
            if (!Services.Authorizer.Authorize(Permissions.ChangePassword, T("Not authorized to manage users")))
                return new HttpUnauthorizedResult();

            var user = Services.ContentManager.Get<UserPart>(model.UserId);

            if (!this.ModelState.IsValid) 
            {
                var viewModel = new ChangePasswordViewModel()
                {
                    UserPart = user,
                    UserId = user.Id
                };

                return View(viewModel);
            }

            _membershipService.SetPassword(user, model.Password);

            notifier.Information(T("User password  for " + user.UserName + " changed!"));

            return RedirectToAction("Index");
        }
Example #25
0
        public bool ChangePassword(ChangePasswordViewModel model, string id)
        {
            var result = _userManager.ChangePassword(id, model.OldPassword, model.NewPassword);

            return(result.Succeeded);
        }
Example #26
0
        public virtual ActionResult ChangePassword()
        {
            var viewModel = new ChangePasswordViewModel();

            return View(viewModel);
        }
        public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (!this.ModelState.IsValid)
            {
                return this.View(model);
            }

            var result = await this.UserManager.ChangePasswordAsync(this.User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
            if (result.Succeeded)
            {
                var user = await this.UserManager.FindByIdAsync(this.User.Identity.GetUserId());
                if (user != null)
                {
                    await this.SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                }

                this.AddToastMessage("Congratulations", "Your password has been changed.", ToastType.Success);
                return this.RedirectToAction<HomeController>(c => c.Index());
            }

            this.AddErrors(result);
            return this.View(model);
        }
Example #28
0
        public IActionResult ChangePassword()
        {
            ChangePasswordViewModel view = new ChangePasswordViewModel();

            return(View("ChangePassword", view));
        }
        public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            string strError = string.Empty;
            try
            {
                if (ModelState.IsValid)
                {
                    await ParseUser.RequestPasswordResetAsync(model.Email);
                    model.Message =  Strings.GetLocalizedString(Strings.ChangePasswordSuccessMessage);
                    model.IsSuccess = true;
                    model.CaptchaOK = true;
                }
                else
                {
                    model.CaptchaOK = false;
                }
            }
            catch (Exception ex)
            {
                strError = ex.ToString();
                model.IsSuccess = false;
            }

            if (!string.IsNullOrEmpty(strError))
            {
                await ParseLogger.Log("Change Password", strError);
                model.Message = MyMentorResources.validationChangePasswordError;
                return View(model);
            }
            return View(model);
        }
Example #30
0
        public ActionResult ChangePassword(string username)
        {
            var model = new ChangePasswordViewModel();

            return(View("ChangePassword", model));
        }
Example #31
0
 public ChangePasswordPopup()
 {
     InitializeComponent();
     BindingContext = new ChangePasswordViewModel();
 }
Example #32
0
        public ActionResult EditUserPassword(int id) 
        {
            if (!Services.Authorizer.Authorize(Permissions.ChangePassword, T("Not authorized to manage users")))
                return new HttpUnauthorizedResult();

            var user = Services.ContentManager.Get<UserPart>(id);
            var viewModel = new ChangePasswordViewModel() { 
                UserPart = user,
                UserId = user.Id
            };

            return View(viewModel);    
        }
        public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordViewModel model)
        {
            IActionResult _result = new ObjectResult(false);
            GenericResult _authenticationResult = null;

            try
            {
                ApplicationUser appUser = null;
                if (!String.IsNullOrEmpty(model.Id))
                {
                    appUser = await _userManager.FindByIdAsync(model.Id);
                }
                else if (!String.IsNullOrEmpty(model.UserName))
                {
                    appUser = await _userManager.FindByNameAsync(model.UserName);
                }
                //else
                //{
                //    appUser = await _userManager.FindByIdAsync(model.Id);
                //}

                if (appUser != null)
                {
                    var result =
                        await
                        _userManager.ChangePasswordAsync(appUser, model.OldPassword, model.NewPassword);

                    if (result.Succeeded)
                    {
                        _authenticationResult = new GenericResult()
                        {
                            Succeeded = true,
                            Message   = "Đổi mật khẩu thành công",
                        };
                    }

                    else
                    {
                        _authenticationResult = new GenericResult()
                        {
                            Succeeded = false,
                            Message   = "Đổi mật khẩu thất bại",
                        };
                    }
                }
                else
                {
                    _authenticationResult = new GenericResult()
                    {
                        Succeeded = false,
                        Message   = "Không tìm thấy ID",
                    };
                }
            }
            catch (Exception ex)
            {
                _authenticationResult = new GenericResult()
                {
                    Succeeded = false,
                    Message   = ex.Message
                };

                _loggingRepository.Add(new Error()
                {
                    Message = ex.Message, StackTrace = ex.StackTrace, DateCreated = DateTime.Now
                });
                _loggingRepository.Commit();
            }

            _result = new ObjectResult(_authenticationResult);
            return(_result);
        }
Example #34
0
        public IActionResult ChangePassword()
        {
            var model = new ChangePasswordViewModel();

            return(View(model));
        }
Example #35
0
        public ActionResult ChangePassword(ChangePasswordViewModel model)
        {
            if (this.ModelState.IsValid)
            {
                var request = new ChangePasswordRequest
                {
                    UserName = "******",
                    OldPassword = model.OldPassword,
                    NewPassword = model.NewPassword
                };

                var response = this.accountService.ChangePassword(request);
                if (response.Status == StatusCode.OK)
                {
                    this.TempData["SuccessMessage"] = "You have successfully changed your password.";
                    return this.RedirectToAction("Index");
                }
                else
                {
                    this.ViewBag.DisplaySummary = "yes";
                    this.ModelState.AddModelError(string.Empty, "Your old password has not been recognised. Please try again.");
                }
            }

            return this.View();
        }
Example #36
0
        public virtual ActionResult ChangePassword()
        {
            var viewModel = new ChangePasswordViewModel();

            return(View(viewModel));
        }
Example #37
0
        public async Task <IActionResult> UserChangePassword(ChangePasswordViewModel user)
        {
            var data = await _userService.UserChangePasswordAsync(user);

            return(Ok(data));
        }
Example #38
0
 protected override void OnNavigatedTo(NavigationEventArgs e)
 {
     User      = new EditAccountViewModel();
     Passwords = new ChangePasswordViewModel();
 }
Example #39
0
        public IActionResult ChangePassword()
        {
            var user = new ChangePasswordViewModel();

            return(View("ChangePassword", user));
        }
Example #40
0
        public IActionResult ChangePassword()
        {
            var passwordViewModel = new ChangePasswordViewModel();

            return(this.View(passwordViewModel));
        }
Example #41
0
        //[ValidateAntiForgeryToken]
        public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var userID = GetCurrentUserID();

                var result = await this.UserManager.ChangePasswordAsync(userID, model.OldPassword, model.NewPassword);
                if (result.Succeeded)
                {
                    var user = await GetCurrentUserAsync();
                    user.ChangedPassword = true;
                    var updateUserResult = await this.UserManager.UpdateAsync(user);
                    if (result.Succeeded)
                    {
                        return Json("OK", JsonRequestBehavior.AllowGet);
                    }
                    else
                    {
                        return JsonMessage.BadRequestJsonResult(updateUserResult.Errors);
                    }
                }
                else
                {
                    return JsonMessage.BadRequestJsonResult(result.Errors);
                }
            }
            return JsonMessage.BadRequestJsonResult(ModelState.Values.SelectMany(x => x.Errors));
        }
        public ActionResult ChangePassword(ChangePasswordViewModel model)
        {
            Func<ChangePasswordViewModel, ChangePasswordViewModel> setCommonValues = delegate(ChangePasswordViewModel modelTmp)
            {
                modelTmp.BaseViewModelInfo.Title = $customNamespace$.Resources.Account.AccountResources.ChangePassword;
                modelTmp.MinPasswordLength = this.FormsMembershipService.Settings().Data.MinRequiredPasswordLength;
                return modelTmp;
            };

            if (this.RequestType() == HttpVerbs.Get)
            {
                model = setCommonValues(new ChangePasswordViewModel());
                return View(model);
            }
            else
            {
                model = setCommonValues(model);

                if (ModelState.IsValid)
                {
                    FormsIdentity identity = this.FormsAuthenticationService.GetFormsIdentity();
                    DataResultBoolean result = this.FormsMembershipService.ChangePassword(identity.Name, model.OldPassword, model.NewPassword, model.ConfirmPassword);
                    if (result.IsValid)
                    {
                        model.Result = result;
                    }
                    else
                    {
                        ModelState.AddModelError("InvalidPassword", result.Message);
                    }
                }
                return View(model);
            }
        }
        public ActionResult ChangePassword()
        {
            ChangePasswordViewModel CPVM = new ChangePasswordViewModel();

            return(View(CPVM));
        }
Example #44
0
        public ActionResult ChangePassword(ChangePasswordViewModel model)
        {
            if (!ModelState.IsValid)
                return View(model);

            using (var Context = new ProjectDBEntities())
            {
                var oldPassword = Hashing.CreateHash(model.OldPassword);
                var user = Context.SiteUsers
                    .Where(x => x.UserName == User.Identity.Name && x.UserPass == oldPassword)
                    .FirstOrDefault<SiteUser>();

                if (user == null)
                {
                    ViewBag.Message = "Old password doesn't match..";
                    return View(model);
                }

                user.UserPass = Hashing.CreateHash(model.NewPassword);

                Context.SaveChanges();

                ViewBag.Message = "Password Changed Successfully..";
                return View(new ChangePasswordViewModel());
            }
        }
        public async Task<ActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }
            var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
            if (result.Succeeded)
            {
                var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
                if (user != null)
                {
                    await SignInAsync(user, isPersistent: false);
                }
                //return RedirectToAction("Index", new { Message = IdentitySample.Controllers.ManageController.ManageMessageId.ChangePasswordSuccess });
                //return RedirectToAction("Index", "Dashboard");
                ViewBag.MessageVM = new MessageViewModel {Message = "Password has been updated.", IsUpdated = true};

                return View();
            }
            else
            {
                ViewBag.MessageVM = new MessageViewModel { Message = "Incorrect old Password", IsError = true };
            }
            AddErrors(result);
            return View(model);
        }
 public ActionResult ChangePassword(ChangePasswordViewModel model)
 {
     ResponseModel response = new ResponseModel();
     UserInfo user = _userInfoService.GetById(model.Id);
     user.Password = model.Password.ToMd5String();
     _userInfoService.Update(user);
     _unitOfWork.Commit();
     response.Msg = "重置密码成功!";
     response.Success = true;
     response.RedirectUrl = string.Empty;
     return Json(response, JsonRequestBehavior.AllowGet);
 }
Example #47
0
		public ActionResult ChangePassword(ChangePasswordViewModel changePasswordViewModel)
		{
			if(!this.ValidateAndForwardMessages(changePasswordViewModel))
			{
				return RedirectToAction("settings", "user");
			}

			using(var unitOfWork = this.UnitOfWorkFactory.NewUnitOfWork())
			{
				try
				{
					if(!this.UserLoginService.VerifyUserPassword(this.ActiveUser.UserId, changePasswordViewModel.CurrentPassword))
					{
                        return Json(new { Success = false, Message = "The current password you provided is not correct" });
					}

					this.UserLoginService.SetUserPassword(this.ActiveUser.UserId, changePasswordViewModel.NewPassword);
					unitOfWork.Commit();
				}
				catch (Exception ex)
				{
					this.LogHandledException(ex);
					unitOfWork.Rollback();
           
                    return Json(new { Success = false, Message = GenericMessages.ErrorMessage });
				}
			}

		    return Json(new { Success = true, Message = "Your password has been changed" });
		}
        public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);

            if (result.Succeeded)
            {
                // Fouche - Update tblCustomer met nuwe PIN.
                string Email = User.Identity.GetUserName();

                tblCustomer tblCustomers  = new tblCustomer();
                tblCustomer tblCustomerEx = db.tblCustomers.FirstOrDefault(i => i.CustomerID == Email);
                // Kry net die ID op tblCustomer

                if (tblCustomerEx == null)  // voeg by
                {
                    //tblCustomers.CustomerID = model.Email; // Kan dalk later verander.
                    //tblCustomers.CustomerID = User.Identity.
                    //tblCustomers.CompanyName = model.CompanyName;
                    //tblCustomers.CompanyID = model.CustomerID;
                    //tblCustomers.eMail = model.Email;
                    //tblCustomers.Phone = model.PhoneNumber;
                    //tblCustomers.ContactPerson = model.ContactPerson;
                    //tblCustomers.CellPhone = model.ContactCellPhone;
                    //tblCustomers.Active = true;
                    //tblCustomers.VATRegistered = false;
                    //tblCustomers.PIN = model.PIN;
                    //companyName = model.CompanyName;
                    //Email = model.Email;

                    //db.tblCustomers.Add(tblCustomers);
                    //db.SaveChanges();
                }
                else
                {
                    //                    tblCustomer tblCustomersF = db.tblCustomers.FirstOrDefault(i => i.CustomerID == model.Email);
                    //db.Entry(tblCustomersF).State = EntityState.Modified;
                    //tblCustomersF.CompanyName = model.CompanyName;
                    //tblCustomersF.CompanyID = model.CustomerID;
                    //tblCustomersF.eMail = model.Email;
                    //tblCustomersF.Phone = model.PhoneNumber;
                    //tblCustomersF.ContactPerson = model.ContactPerson;
                    //tblCustomersF.CellPhone = model.ContactCellPhone;
                    //                   tblCustomerEx.Active = true;
                    //                   tblCustomerEx.VATRegistered = false;
                    tblCustomerEx.PIN = model.PIN;
                    //companyName = model.CompanyName;
                    //Email = model.Email;
                    db.CustomersPIN(tblCustomerEx.ID, model.PIN);

//                    db.SaveChanges();
                }


                // Fouche - end
                var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());

                if (user != null)
                {
                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
                }
                return(RedirectToAction("Index", "Home", new { Message = ManageMessageId.ChangePasswordSuccess }));
            }
            AddErrors(result);
            return(View(model));
        }
 public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model)
 {
     if (!ModelState.IsValid)
     {
         return View(model);
     }
     var user = await GetCurrentUserAsync();
     if (user != null)
     {
         var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
         if (result.Succeeded)
         {
             await _signInManager.SignInAsync(user, isPersistent: false);
             _logger.LogInformation(3, "User changed their password successfully.");
             return RedirectToAction(nameof(Index), new { Message = ManageMessageId.ChangePasswordSuccess });
         }
         AddErrors(result);
         return View(model);
     }
     return RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error });
 }
Example #50
0
 public ActionResult ChangePassword()
 {
     ChangePasswordViewModel vModel = new ChangePasswordViewModel();
     return View(vModel);
 }