Integracja Fluent Validation z ASP.NET MVC

CreateUserViewModel.cs

[Validator(typeof(CreateUserViewModelValidator))]
public class CreateUserViewModel
{
    public string Email { get; set; }

    public bool CreateInvoice { get; set; }

    public string Nip { get; set; }
}

CreateUserViewModelValidator.cs

public class CreateUserViewModelValidator : AbstractValidator<CreateUserViewModel>
{
    public CreateUserViewModelValidator()
    {
        RuleFor(u => u.Email)
            .Cascade(CascadeMode.StopOnFirstFailure)
            .NotEmpty()
            .EmailAddress();

        RuleFor(u => u.Nip)
            .NotEmpty()
            .When(u => u.CreateInvoice);
    }
}

Global.asax.cs

FluentValidationModelValidatorProvider.Configure();

Result.cs

public class Result
{
    public bool Success { get; set; }
    
    public IEnumerable<ErrorMessage> Errors { get; set; }

    public static Result<T> Ok<T>(T value)
    {
        return new Result<T>()
        {
            Success = true,
            Value = value
        };
    }

    public static Result<T> Failure<T>(IEnumerable<ValidationFailure> validationFailures)
    {
        var result = new Result<T>();

        result.Success = false;
        result.Errors = validationFailures.Select(v => new ErrorMessage()
        {
            PropertyName = v.PropertyName,
            Message = v.ErrorMessage
        });

        return result;
    }
}

public class Result<T> : Result
{
    public T Value { get; set; }
}

public class ErrorMessage
{
    public string PropertyName { get; set; }

    public string Message { get; set; }
}

ResultExtensions.cs

public static class ResultExtensions
{
    public static void AddErrorToModelState(this Result result, ModelStateDictionary modelState)
    {
        if (result.Success)
        {
            return;
        }

        foreach (var error in result.Errors)
        {
            modelState.AddModelError(error.PropertyName, error.Message);
        }
    }
}

User.cs

public class User
{
    public string Email { get; set; }

    public bool CreateInvoice { get; set; }

    public string Nip { get; set; }
}

UsersController1.cs

[HttpGet]
public ActionResult ViewModel()
{
    return View(new CreateUserViewModel());
}

[HttpPost]
public ActionResult ViewModel(CreateUserViewModel viewModel)
{
    if(ModelState.IsValid == false)
    {
        return View(viewModel);
    }

    return Content("Dodano");
}

UsersController2.cs

[HttpGet]
public ActionResult Model()
{
    return View(new CreateWithModelUserViewModel());
}

[HttpPost]
public ActionResult Model(CreateWithModelUserViewModel viewModel)
{
    if(ModelState.IsValid == false)
    {
        return View(viewModel);
    }

    var user = new User() //I normally use the automapper to map model <-> viewmodel
    {
        Email = viewModel.Email,
        CreateInvoice = viewModel.CreateInvoice,
        Nip = viewModel.Nip
    };

    var result = UsersLogic.Create(user);

    if(result.Success == false)
    {
        result.AddErrorToModelState(ModelState);
        return View(viewModel);
    }

    return Content("Dodano");
}

UsersLogic.cs

public class UsersLogic
{
    protected UserValidator Validator { get; set; }

    public UsersLogic()
    {
        Validator = new UserValidator();
    }

    public Result<User> Create(User user)
    {
        var validationResult = Validator.Validate(user);

        if(validationResult.IsValid == false)
        {
            return Result.Failure<User>(validationResult.Errors);
        }

        //zapis danych do bazy

        return Result.Ok<User>(user);
    }
}

UserValidator.cs

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(u => u.Email)
            .Cascade(CascadeMode.StopOnFirstFailure)
            .NotEmpty()
            .EmailAddress();

        RuleFor(u => u.Nip)
            .NotEmpty()
            .When(u => u.CreateInvoice);
    }
}