public async Task <Result> ResetPassword(ResetPassword resetPassword)
        {
            var validator = new ResetPasswordValidator();
            var result    = validator.Validate(resetPassword).GetResult();

            if (!result.Success)
            {
                return(result);
            }

            var user = await _userManager.FindByNameAsync(resetPassword.UserName);

            var activateResult = await _userManager.ResetPasswordAsync(user, resetPassword.Token, resetPassword.Password);

            if (!activateResult.Succeeded)
            {
                foreach (var error in activateResult.Errors)
                {
                    result.AddValidationFailure("", error.Description);
                }

                return(result);
            }

            if (!user.EmailConfirmed)
            {
                user.EmailConfirmed = true;
                await _userManager.UpdateAsync(user);
            }

            return(result);
        }
        public void ValidWhenAllDataProvided()
        {
            // arrange
            var validator = new ResetPasswordValidator();
            var dto       = new ResetPasswordDto
            {
                Email             = validEmail,
                Token             = validToken,
                Password          = validPassword,
                ConfirmedPassword = validPassword
            };
            // act
            var result = validator.Validate(dto);

            // assert
            Assert.True(result.IsValid);
        }
        public void InvalidWhenPasswordDifferentThanConfirmedPassword()
        {
            // arrange
            var validator = new ResetPasswordValidator();
            var dto       = new ResetPasswordDto
            {
                Email             = validEmail,
                Token             = validToken,
                Password          = validPassword,
                ConfirmedPassword = differentPassword
            };
            // act
            var result = validator.Validate(dto);

            // assert
            Assert.False(result.IsValid);
        }
        public void InvalidWhenPasswordNotProvided(string password)
        {
            // arrange
            var validator = new ResetPasswordValidator();
            var dto       = new ResetPasswordDto
            {
                Email             = validEmail,
                Token             = validToken,
                Password          = password,
                ConfirmedPassword = password
            };
            // act
            var result = validator.Validate(dto);

            // assert
            Assert.False(result.IsValid);
        }
        public void Should_ReturnFalse_WhenRequiredInfo_IsNotProvided(string email, string password, string passwordResetToken)
        {
            // Arrange
            var resetPasswordDto = new ResetPasswordDto
            {
                Email              = email,
                Password           = password,
                PasswordResetToken = passwordResetToken
            };

            var resetPasswordValidator = new ResetPasswordValidator();

            // Act
            var validatorResult = resetPasswordValidator.Validate(resetPasswordDto);

            // Assert
            validatorResult.IsValid.ShouldBeFalse();
        }
Пример #6
0
        public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordModel model)
        {
            #region Validate Model

            var userInputValidated = _resetPasswordValidator.Validate(model);

            if (!userInputValidated.IsValid)
            {
                _infos.Add(_badRequest.ShowError(int.Parse(userInputValidated.Errors[0].ErrorMessage)).Message);

                return(BadRequest(new CustomResponse <string> {
                    Message = _infos
                }));
            }

            #endregion

            var resetPassword = await _user.ResetPassword(model);

            return(Ok(resetPassword));
        }