Benutzerdefinierte Validierung Attribut Mehrere Male auf dem gleichen Feld

Das Problem

Validierung Attribute haben zwei Umgebungen können Sie überprüfen gegen:

1. Server
2. Client

Server-Validierung - Mehrere Attribute Einfach

Wenn Sie keine attribute mit:

[AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
public class RequiredIfAttribute : ValidationAttribute

Haben und legen Sie es auf Ihrem class-Eigenschaft wie folgt:

public class Client
{
    public short ResidesWithCd { get; set; };

    [RequiredIf(nameof(ResidesWithCd), new[] { 99 }, "Resides with other is required.")]
    public string ResidesWithOther { get; set; }
}

Dann jederzeit die Server geht validieren Sie ein Objekt (ex. ModelState.IsValid es prüfen jedes ValidationAttribute auf jede Eigenschaft, und rufen Sie .IsValid() Gültigkeit bestimmen. Dies funktioniert gut, auch wenn AttributeUsage.AllowMultiple auf true gesetzt ist.

Client-Validierung - HTML-Attribut Engpass

Beim aktivieren der client-Seite durch die Umsetzung IClientValidatable wie diese:

public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)    
{
    var modelClientValidationRule = new ModelClientValidationRule
    {
        ValidationType = "requiredif",
        ErrorMessage = ErrorMessageString
    };
    modelClientValidationRule.ValidationParameters.Add("target", prop.PropName);
    modelClientValidationRule.ValidationParameters.Add("values", prop.CompValues);

    return new List<ModelClientValidationRule> { modelClientValidationRule };
}

Dann ASP.NET emittiert wird der folgende HTML-Code generiert, wenn:

^{(solange ClientValidationEnabled &
UnobtrusiveJavaScriptEnabled sind aktiviert)}

<input class="form-control" type="text" value=""
       id="Client_CommunicationModificationDescription" 
       name="Client.CommunicationModificationDescription" 
       data-val="true"
       data-val-requiredif="Communication Modification Description is required."
       data-val-requiredif-target="CommunicationModificationCd"
       data-val-requiredif-values="99" >

Data-Attribute sind das einzige Fahrzeug haben wir für dumping-Regeln in die client-seitige Validierung engine, die Suche nach beliebigen Attributen auf der Seite über eine integrierte oder benutzerdefinierte adapter. Und einmal ein Teil der Reihe von client-seitige Regeln, es werden in der Lage, um zu bestimmen, die Gültigkeit eines jeden analysiert-in der Regel mit einer integrierten oder benutzerdefinierten Methode.

Also wir können hoch jQuery Validierung Unauffällig zu schauen und zu analysieren, diese Attribute durch hinzufügen einer benutzerdefinierten adapter die eine Gültigkeitsregel zum Motor:

//hook up to client side validation
$.validator.unobtrusive.adapters.add('requiredif', ['target', 'values'], function (options) {
    options.rules["requiredif"] = {
        id: '#' + options.params.target,
        values: JSON.parse(options.params.values)
    };
    options.messages['requiredif'] = options.message;
});

Dann können wir sagen, dass die Regel wie die Funktion, und bestimmen Sie die Gültigkeit, indem Sie hinzufügen einer benutzerdefinierten Methode wie diese, die wird hinzufügen einer benutzerdefinierten Art und Weise zu bewerten requiredif Regeln (im Gegensatz zum Datum-Regeln oder-regex-Regeln), die sich auf die Parameter, die wir früher geladenen, die über den adapter:

//test validity
$.validator.addMethod('requiredif', function (value, element, params) {
    var targetHasCondValue = targetElHasValue(params.id, params.value);
    var requiredAndNoValue = targetHasCondValue && !value; //true -> :(
    var passesValidation = !requiredAndNoValue;            //true -> :)
    return passesValidation;
}, '');

Denen alles funktioniert wie dies:

Lösung

So, was haben wir gelernt? Nun, wenn wir wollen, dass die gleiche Regel erscheinen mehrmals auf das gleiche element, der adapter würde um die genauen Regeln mehrere Male pro element, ohne die Möglichkeit zu differenzieren, zwischen jeder Instanz in mehrere sets. Weiter, ASP.NET nicht machen die gleichen Attribut-Namen mehrere Male, denn es ist kein Gültiger html-Code.

Also, wir müssen entweder:

1. Alle ausblenden, um die client-seitige Regeln in einem einzigen mega Attribut mit allen Infos, die
2. Attribute umbenennen, mit jeder Instanz-Nummer und dann einen Weg finden, zu analysieren, Sie in Sätzen.

Werde ich untersuchen Option Einer (aussenden eines einzigen client-Seite-Attribut), was könnten Sie tun, ein paar Möglichkeiten:

1. Erstellen Sie ein einzelnes Attribut, das dauert in der mehrere Elemente zu überprüfen, die auf dem server-client
2. Halten mehrere verschiedene server-side-Attribute und führen alle Attribute per reflection vor emitting an den client

In beiden Fällen werden Sie müssen re-schreiben Sie die client-seitige Logik (adapter/- Methode), um ein array von Werten anstelle eines einzelnen Wertes zu einem Zeitpunkt.

Zu werden wir erstellen/übertragen einer JSON-serialisiertes Objekt, das aussieht wie dieses:

var props = [
  {
    PropName: "RoleCd",
    CompValues: ["2","3","4","5"]
  },
  {
    PropName: "IsPatient",
    CompValues: ["true"]
  }
]

Scripts/ValidateRequiredIfAny.js

Hier ist, wie wir damit umgehen, dass in client-side-adapter /- Methode:

//hook up to client side validation
$.validator.unobtrusive.adapters.add("requiredifany", ["props"], function (options) {
    options.rules["requiredifany"] = { props: options.params.props };
    options.messages["requiredifany"] = options.message;
});

//test validity
$.validator.addMethod("requiredifany", function (value, element, params) {
    var reqIfProps = JSON.parse(params.props);
    var anytargetHasValue = false;

    $.each(reqIfProps, function (index, item) {
        var targetSel = "#" + buildTargetId(element, item.PropName);
        var $targetEl = $(targetSel);
        var targetHasValue = elHasValue($targetEl, item.CompValues);

        if (targetHasValue) {
            anytargetHasValue = true;
            return ;
        }
    });

    var valueRequired = anytargetHasValue;
    var requiredAndNoValue = valueRequired && !value; //true -> :(
    var passesValidation = !requiredAndNoValue;       //true -> :)
    return passesValidation;

}, "");

//UTILITY METHODS

function buildTargetId(currentElement, targetPropName) {
    //https://stackoverflow.com/a/39725539/1366033
    //we are only provided the name of the target property
    //we need to build it's ID in the DOM based on a couple assumptions
    //derive the stacking context and depth based on the current element's ID/name
    //append the target property's name to that context

                                                //currentElement.name i.e. Details[0].DosesRequested
    var curId = currentElement.id;              //get full id         i.e. Details_0__DosesRequested
    var context = curId.replace(/[^_]+$/, "");  //remove last prop    i.e. Details_0__
    var targetId = context + targetPropName;    //build target ID     i.e. Details_0__OrderIncrement

    //fail noisily
    if ($("#" + targetId).length === 0)
        console.error(
            "Could not find id '" + targetId +
            "' when looking for '" + targetPropName +
            "'  on originating element '" + curId + "'");

    return targetId;
}

function elHasValue($el, values) {
    var isCheckBox = $el.is(":checkbox,:radio");
    var isChecked = $el.is(":checked");
    var inputValue = $el.val();
    var valueInArray = $.inArray(String(inputValue), values) > -1;

    var hasValue = (!isCheckBox || isChecked) && valueInArray;

    return hasValue;
};

Models/RequiredIfAttribute.cs

Auf der server-Seite werden wir überprüfen Attribute wie normal, aber wenn wir zu bauen die client-Seite Attribute, schauen wir für alle Attribute und bauen eine mega-Attribut

using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Web.Helpers;
using System.Web.Mvc;

[AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
public class RequiredIfAttribute : ValidationAttribute, IClientValidatable
{

    public PropertyNameValues TargetProp { get; set; }

    public RequiredIfAttribute(string compPropName, string[] compPropValues, string msg) : base(msg)
    {
        this.TargetProp = new PropertyNameValues()
        {
            PropName = compPropName,
            CompValues = compPropValues
        };
    }
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        PropertyInfo compareProp = validationContext.ObjectType.GetProperty(TargetProp.PropName);
        var compPropVal = compareProp.GetValue(validationContext.ObjectInstance, null);
        string compPropValAsString = compPropVal?.ToString().ToLower() ?? "";
        var matches = TargetProp.CompValues.Where(v => v == compPropValAsString);
        bool needsValue = matches.Any();

        if (needsValue)
        {
            if (value == null || value.ToString() == "" || value.ToString() == "0")
            {
                return new ValidationResult(FormatErrorMessage(null));
            }
        }

        return ValidationResult.Success;
    }


    public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {
        //at this point, who cares that we're on this particular instance - find all instances
        PropertyInfo curProp = metadata.ContainerType.GetProperty(metadata.PropertyName);
        RequiredIfAttribute[] allReqIfAttr = curProp.GetCustomAttributes<RequiredIfAttribute>().ToArray();

        //emit validation attributes from all simultaneously, otherwise each will overwrite the last
        PropertyNameValues[] allReqIfInfo = allReqIfAttr.Select(x => x.TargetProp).ToArray();
        string allReqJson = Json.Encode(allReqIfInfo);

        var modelClientValidationRule = new ModelClientValidationRule
        {
            ValidationType = "requiredifany",
            ErrorMessage = ErrorMessageString
        };

        //add name for jQuery parameters for the adapter, must be LOWERCASE!
        modelClientValidationRule.ValidationParameters.Add("props", allReqJson);

        return new List<ModelClientValidationRule> { modelClientValidationRule };
    }
}

public class PropertyNameValues
{
    public string PropName { get; set; }
    public string[] CompValues { get; set; }
}

Dann können wir binden, dass an unserem Modell durch die Anwendung mehrerer Attribute gleichzeitig:

[RequiredIf(nameof(RelationshipCd), new[] { 1,2,3,4,5 }, "Mailing Address is required.")]
[RequiredIf(nameof(IsPatient), new[] { "true" },"Mailing Address is required.")]
public string MailingAddressLine1 { get; set; }

Weiter Lesen

• ASP.NET MVC mehrere benutzerdefinierte Felder Validierung von Stephen Muecke
• Unauffällig Client-Validierung in ASP.NET MVC-3 von Brad Wilson