public async Task <IActionResult> UpdateUserPassword(UserEditPasswordViewModel model)
        {
            var user = await _userManager.FindByIdAsync(model.Id);

            if (ModelState.IsValid)
            {
                var passwordValidator = new PasswordValidator <AppUser>();
                var validationResult  = await passwordValidator.ValidateAsync(_userManager, user, model.Password);

                if (!validationResult.Succeeded)
                {
                    foreach (var error in validationResult.Errors)
                    {
                        ModelState.AddModelError(string.Empty, error.Description);
                    }
                }
                else
                {
                    user.PasswordHash = _passwordHasher.HashPassword(user, model.Password);
                    var result = await _userManager.UpdateAsync(user);

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

                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError(string.Empty, error.Description);
                    }
                }
            }

            return(View(model));
        }
Пример #2
0
        protected override DriverResult Editor(UserPart part, IUpdateModel updater, dynamic shapeHelper)
        {
            var editModel = new UserEditPasswordViewModel {
                User = part
            };

            if (updater != null)
            {
                if (updater.TryUpdateModel(editModel, Prefix, null, null))
                {
                    if (!(string.IsNullOrEmpty(editModel.Password) && string.IsNullOrEmpty(editModel.ConfirmPassword)))
                    {
                        if (string.IsNullOrEmpty(editModel.Password) || string.IsNullOrEmpty(editModel.ConfirmPassword))
                        {
                            updater.AddModelError("MissingPassword", T("Password or Confirm Password field is empty."));
                        }
                        else
                        {
                            if (editModel.Password != editModel.ConfirmPassword)
                            {
                                updater.AddModelError("ConfirmPassword", T("Password confirmation must match."));
                            }
                            var actUser = _membershipService.GetUser(part.UserName);
                            _membershipService.SetPassword(actUser, editModel.Password);
                        }
                    }
                }
            }
            return(Editor(part, shapeHelper));
        }
Пример #3
0
        public async Task UserEditPassword([FromForm] UserEditPasswordViewModel model)
        {
            var currentUserId = EngineContext.Current.ClaimManager.GetUserId();
            var command       =
                new UserEditPasswordCommand(currentUserId.ToHasGuid().Value, model.OldPassword, model.NewPassword);
            await _bus.SendCommand(command);

            if (_notifications.HasNotifications())
            {
                var errorMessage = _notifications.GetNotificationMessage();
                throw new GirvsException(StatusCodes.Status400BadRequest, errorMessage);
            }
        }
        public async Task <IActionResult> UpdateUserPassword(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return(RedirectToAction("Users"));
            }

            var user = await _userManager.FindByIdAsync(id);

            if (user == null)
            {
                return(RedirectToAction("Users"));
            }

            var model = new UserEditPasswordViewModel
            {
                Email = user.Email
            };

            return(View(model));
        }