c# - aspnetcore - FluentValidation: compruebe si uno de los dos campos está vacío

fluentvalidation aspnetcore

Question

Tengo este modelo

public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }  
}

Quiero crear una validación donde FirstName o LastName deben ser completados por el usuario. Instalé FluentValidation y creé una clase FluentValidation

public class PersonValidator:AbstractValidator<Person>
{
    public PersonValidator()
    {
        RuleFor((person=>person.FirstName)//don''t know how to check if one is empty
    }
}

Para verificar solo un campo, podría hacer RuleFor(person => person.FirstName).NotNull();

Pero, ¿cómo puedo verificar si uno de ellos es nulo?

Además, ¿es posible que, una vez que se haya creado la validación mediante fluentValidation , la use en el lado del cliente para mostrar el error?

Edit1

    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();

        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);
        FluentValidationModelValidatorProvider.Configure();
    }
//creating validation
namespace WebApplication1.Models.CustomValidator
{
    public class PersonValidator:AbstractValidator<Person>
    {
        public PersonValidator()
        {
            RuleFor(m => m.FirstName).NotEmpty().When(m => string.IsNullOrEmpty(m.LastName)).WithMessage("*Either First Name or Last Name is required");
            RuleFor(m => m.LastName).NotEmpty().When(m => string.IsNullOrEmpty(m.FirstName)).WithMessage("*Either First Name or Last Name is required");
        }
    }

}
//model class
[Validator(typeof(PersonValidator))]
public class Person
{
    public Person()
    {
        InterestList = new List<string>();
    }
    public int Id { get; set; }
    public int ContactId { get; set; }
    [RequiredIfEmpty("LastName")]
    public string FirstName { get; set; }
    [RequiredIfEmpty("FirstName")]
    public string LastName { get; set; }
    public string EmailAddress { get; set; }
    public string Phone { get; set; }
    public string Country { get; set; }
    public List<string> InterestList { get; set; } 
}
//view
@model WebApplication1.Models.Person

<script src="@Url.Content("~/Scripts/jquery-1.8.2.min.js")"></script>
<script src="@Url.Content("~/Scripts/jquery.validate.min.js")"></script>
<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")"></script>
<script src="@Url.Content("~/Scripts/jquery.unobtrusive-ajax.min.js")" type="text/javascript"></script>

@Html.ValidationSummary(true)
@using(Html.BeginForm("AddPerson","Person",FormMethod.Post))
{
    <div class="label">First Name</div>
    <div class="input-block-level">@Html.TextBoxFor(m=>m.FirstName)@Html.ValidationMessageFor(m=>m.FirstName)</div>
    <br/>
    <div class="label">Last Name</div>
    <div class="input-block-level">@Html.TextBoxFor(m=>m.LastName)@Html.ValidationMessageFor(m=>m.LastName)</div>
    <button type="submit" class="btn-primary">Submit</button>
}

Answer 1

Me gustó esto para verificar que los cargos ingresados ​​sean los mismos que en el anterior o no. Si los cargos son los mismos que el anterior, dará un error. Esto funcionó para mí.

public class CasualMealChargeValidator : AbstractValidator<CasualMealCharge>
{
    public CasualMealChargeValidator(CasualMealCharge CMC)
    {
        //RuleFor(x => x.BankName).NotEmpty().When(pm => pm.PaymentMode == "Cheque").WithMessage("Enter Bank.");
        RuleFor(x => x).Must(x => x.DN != CMC.DN || x.BF != CMC.BF || x.LN != CMC.LN).WithMessage("Not Saved - Meal charges are same as current charges.").WithName("CMFor");
    }
}

Answer 2

No conozco esa biblioteca, pero si solo quieres verificar esas dos propiedades para nulo, entonces puedes usar esto:

RuleFor(person => person.FirstName ?? person.LastName).NotNull();

EDITAR Esto no funciona, porque arroja una InvalidOperationException . Usa la solución de Zabavsky en su lugar.

Answer 3

Prueba esto

RuleFor(person => person).Must(person => !string.IsNullOrEmpty(person.FirstName) || !string.IsNullOrEmpty(person.LastName))

Answer 4

Puede usar la condición Cuando / A menos :

RuleFor(m => m.FirstName).NotEmpty().When(m => string.IsNullOrEmpty(m.LastName));
RuleFor(m => m.LastName).NotEmpty().When(m => string.IsNullOrEmpty(m.FirstName));

o

RuleFor(m => m.FirstName).NotEmpty().Unless(m => !string.IsNullOrEmpty(m.LastName));
RuleFor(m => m.LastName).NotEmpty().Unless(m => !string.IsNullOrEmpty(m.FirstName));

En cuanto a su segunda pregunta, FluentValidation funciona con la validación del lado del cliente, pero no todas las reglas son compatibles. Aquí puede encontrar validadores, que son compatibles con el lado del cliente:

1. NotNull / NotEmpty
2. Partidos (regex)
3. Incluido entre (rango)
4. Tarjeta de crédito
5. Email
6. EqualTo (comparación de igualdad entre propiedades)
7. Longitud

Para reglas que no están en la lista, debe escribir su propio FluentValidationPropertyValidator e implementar GetClientValidationRules . Puede encontrar algunas muestras de esto en haciendo una búsqueda simple.

Answer 5

RuleFor (person => person) .Must (person =>! String.IsNullOrEmpty (person.FirstName) ||! String.IsNullOrEmpty (person.LastName)). WithName ("Nombre")