MVC3 Validation du Besoin de l'Une De Groupe

Le suivant viewmodel:

public class SomeViewModel
{
  public bool IsA { get; set; }
  public bool IsB { get; set; }
  public bool IsC { get; set; } 
  //... other properties
}

Je souhaite créer un attribut personnalisé qui valide au moins l'une des propriétés disponibles sont remplies. Je prévois être en mesure de joindre un attribut à une propriété et d'attribuer un nom de groupe comme suit:

public class SomeViewModel
{
  [RequireAtLeastOneOfGroup("Group1")]
  public bool IsA { get; set; }

  [RequireAtLeastOneOfGroup("Group1")]
  public bool IsB { get; set; }

  [RequireAtLeastOneOfGroup("Group1")]
  public bool IsC { get; set; } 

  //... other properties

  [RequireAtLeastOneOfGroup("Group2")]
  public bool IsY { get; set; }

  [RequireAtLeastOneOfGroup("Group2")]
  public bool IsZ { get; set; }
}

Je tiens à valider sur le côté client avant la soumission du formulaire en tant que valeurs dans le formulaire de changer et c'est pourquoi je préfère éviter un niveau de classe de l'attribut si possible.

Cela nécessite à la fois côté serveur et côté client validation de localiser toutes les propriétés ayant un objet identique nom de groupe de valeurs transmis en tant que paramètre de l'attribut personnalisé. Est-ce possible? De toute orientation est très apprécié.

InformationsquelleAutor Shawn | 2011-08-30

Voici une façon de procéder (il y a d'autres façons, je suis juste illustrant un seul qui correspondent à votre modèle de vue, comme l'est):

[AttributeUsage(AttributeTargets.Property)]
public class RequireAtLeastOneOfGroupAttribute: ValidationAttribute, IClientValidatable
{
public RequireAtLeastOneOfGroupAttribute(string groupName)
{
ErrorMessage = string.Format("You must select at least one value from group \"{0}\"", groupName);
GroupName = groupName;
}
public string GroupName { get; private set; }
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
foreach (var property in GetGroupProperties(validationContext.ObjectType))
{
var propertyValue = (bool)property.GetValue(validationContext.ObjectInstance, null);
if (propertyValue)
{
//at least one property is true in this group => the model is valid
return null;
}
}
return new ValidationResult(FormatErrorMessage(validationContext.DisplayName));
}
private IEnumerable<PropertyInfo> GetGroupProperties(Type type)
{
return
from property in type.GetProperties()
where property.PropertyType == typeof(bool)
let attributes = property.GetCustomAttributes(typeof(RequireAtLeastOneOfGroupAttribute), false).OfType<RequireAtLeastOneOfGroupAttribute>()
where attributes.Count() > 0
from attribute in attributes
where attribute.GroupName == GroupName
select property;
}
public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
{
var groupProperties = GetGroupProperties(metadata.ContainerType).Select(p => p.Name);
var rule = new ModelClientValidationRule
{
ErrorMessage = this.ErrorMessage
};
rule.ValidationType = string.Format("group", GroupName.ToLower());
rule.ValidationParameters["propertynames"] = string.Join(",", groupProperties);
yield return rule;
}
}

Maintenant, nous allons définir un contrôleur:

public class HomeController : Controller
{
public ActionResult Index()
{
var model = new SomeViewModel();
return View(model);        
}
[HttpPost]
public ActionResult Index(SomeViewModel model)
{
return View(model);
}
}

et une vue:

@model SomeViewModel
<script src="@Url.Content("~/Scripts/jquery.validate.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.js")" type="text/javascript"></script>
@using (Html.BeginForm())
{
@Html.EditorFor(x => x.IsA)
@Html.ValidationMessageFor(x => x.IsA)
<br/>
@Html.EditorFor(x => x.IsB)<br/>
@Html.EditorFor(x => x.IsC)<br/>
@Html.EditorFor(x => x.IsY)
@Html.ValidationMessageFor(x => x.IsY)
<br/>
@Html.EditorFor(x => x.IsZ)<br/>
<input type="submit" value="OK" />
}

La dernière partie que la gauche serait à inscrire des adaptateurs pour le côté client de validation:

jQuery.validator.unobtrusive.adapters.add(
'group', 
[ 'propertynames' ],
function (options) {
options.rules['group'] = options.params;
options.messages['group'] = options.message;
}
);
jQuery.validator.addMethod('group', function (value, element, params) {
var properties = params.propertynames.split(',');
var isValid = false;
for (var i = 0; i < properties.length; i++) {
var property = properties[i];
if ($('#' + property).is(':checked')) {
isValid = true;
break;
}
}
return isValid;
}, '');

En fonction de vos exigences, le code pourrait être adapté.

De loin l'une des meilleures réponses à une question que j'ai jamais reçu. Non seulement pour l'invite et de réponse claire, mais pour fournir un fonctionnement exemple à partir de laquelle je peux apprendre. Je souhaite que je pourrais marquer votre réponse comme une réponse à de multiples reprises.
Une petite correction dans cette ligne de code jQuery var properties = params.propertynames.split(','); devrait être var properties = params.properties.split(',');
C'est une bonne réponse (+1). J'ai un petit problème avec elle, cependant. Le RequireAtLeastOneOfGroup attribut s'applique à trois domaines différents, générant trois règles côté client, ce qui montre trois erreurs dans le résumé. Est-il un moyen de regrouper les règles en une seule règle côté client, tels que la validation de l'état couvre les trois domaines à la fois?
vous pouvez contourner ce problème en utilisant la validation des messages par un membre de chaque groupe au lieu de la synthèse @Html.ValidationMessageFor(x => x.OneMemberOfTheGroup) vous pouvez ensuite ajouter un true pour le résumé de l'appel d'exclure les erreurs de propriété. pas l'idéal, je sais, mais c'est un moyen de contourner le problème
Vous avez une ligne disant rule.ValidationType = string.Format("group", GroupName.ToLower()); qui ne semble pas juste, car le nom du groupe n'est pas dans les cordes de n'importe où. Ce qui est censé être?
Il faut lire la règle.ValidationType = "groupe";

InformationsquelleAutor Darin Dimitrov

Utilisation de `require_from_group` de jquery-équipe de validation:

jQuery validation projet a un sous-dossier dans src dossier appelé supplémentaires.
Vous pouvez le vérifier ici.

Dans ce dossier, nous avons beaucoup de supplémentaires de validation des méthodes qui ne sont pas communs, c'est pourquoi ils ne sont pas ajoutés par défaut.

Comme vous le voyez dans ce dossier, il existe de nombreuses méthodes que vous devez choisir en choisissant la méthode de validation que vous avez réellement besoin.

Basé sur votre question, la méthode de validation que vous avez besoin est nommé require_from_group de dossier supplémentaire.
Il suffit de télécharger ce fichier associé qui est situé ici et le mettre dans votre Scripts dossier de l'application.

La documentation de cette méthode explique ceci:

Permet de dire "au moins X entrées qui correspondent sélecteur de Y doit être rempli."

Le résultat final est qu'aucune de ces entrées:

...validera, sauf si au moins l'un d'eux est rempli.

reference: {require_from_group: [1,".productinfo"]},
description: {require_from_group: [1,".productinfo"]}

options[0]: nombre de champs qui doivent être remplis dans le groupe
optionsDeux: sélecteur CSS qui définit le groupe des personnes les champs obligatoires

Pourquoi vous devez choisir cette mise en œuvre :

Cette méthode de validation est générique et fonctionne pour tous les input (texte, case à cocher, radio, etc), textarea et select. Cette méthode vous permet également de spécifier le nombre minimum d'intrants requis qui doivent être remplis e.g

partnumber:     {require_from_group: [2,".productinfo"]},
category:       {require_from_group: [2,".productinfo"]},
description:    {require_from_group: [2,".productinfo"]}

J'ai créé deux classes RequireFromGroupAttribute et RequireFromGroupFieldAttribute qui vous aidera à la fois côté serveur et côté client validations

`RequireFromGroupAttribute` définition de la classe

RequireFromGroupAttribute seulement dérive de Attribute. La classe est d'utiliser seulement pour la configuration, par exemple en fixant le nombre de champs qui doivent être remplis pour la validation. Vous devez fournir à cette classe le sélecteur CSS classe qui sera utilisée par la méthode de validation pour obtenir tous les éléments du même groupe. Parce que le nombre par défaut des champs requis est de 1 alors cet attribut est utilisé uniquement pour la décoration de votre modèle si le minimum requis dans les spcefied groupe est plus grand que le nombre par défaut.

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class RequireFromGroupAttribute : Attribute
{
public const short DefaultNumber = 1;
public string Selector { get; set; }
public short Number { get; set; }
public RequireFromGroupAttribute(string selector)
{
this.Selector = selector;
this.Number = DefaultNumber;
}
public static short GetNumberOfRequiredFields(Type type, string selector)
{
var requiredFromGroupAttribute = type.GetCustomAttributes<RequireFromGroupAttribute>().SingleOrDefault(a => a.Selector == selector);
return requiredFromGroupAttribute?.Number ?? DefaultNumber;
}
}

`RequireFromGroupFieldAttribute` définition de la classe

RequireFromGroupFieldAttribute qui dérive de ValidationAttribute et met en œuvre IClientValidatable. Vous devez utiliser cette classe dans chaque propriété dans votre modèle, qui participe à votre groupe de validation. Vous devez passer le sélecteur css de la classe.

[AttributeUsage(AttributeTargets.Property)]
public class RequireFromGroupFieldAttribute : ValidationAttribute, IClientValidatable
{
public string Selector { get; }
public bool IncludeOthersFieldName { get; set; }
public RequireFromGroupFieldAttribute(string selector)
: base("Please fill at least {0} of these fields")
{
this.Selector = selector;
this.IncludeOthersFieldName = true;
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var properties = this.GetInvolvedProperties(validationContext.ObjectType); ;
var numberOfRequiredFields = RequireFromGroupAttribute.GetNumberOfRequiredFields(validationContext.ObjectType, this.Selector);
var values = new List<object> { value };
var otherPropertiesValues = properties.Where(p => p.Key.Name != validationContext.MemberName)
.Select(p => p.Key.GetValue(validationContext.ObjectInstance));
values.AddRange(otherPropertiesValues);
if (values.Count(s => !string.IsNullOrWhiteSpace(Convert.ToString(s))) >= numberOfRequiredFields)
{
return ValidationResult.Success;
}
return new ValidationResult(this.GetErrorMessage(numberOfRequiredFields, properties.Values), new List<string> { validationContext.MemberName });
}
public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
{
var properties = this.GetInvolvedProperties(metadata.ContainerType);
var numberOfRequiredFields = RequireFromGroupAttribute.GetNumberOfRequiredFields(metadata.ContainerType, this.Selector);
var rule = new ModelClientValidationRule
{
ValidationType = "requirefromgroup",
ErrorMessage = this.GetErrorMessage(numberOfRequiredFields, properties.Values)
};
rule.ValidationParameters.Add("number", numberOfRequiredFields);
rule.ValidationParameters.Add("selector", this.Selector);
yield return rule;
}
private Dictionary<PropertyInfo, string> GetInvolvedProperties(Type type)
{
return type.GetProperties()
.Where(p => p.IsDefined(typeof(RequireFromGroupFieldAttribute)) &&
p.GetCustomAttribute<RequireFromGroupFieldAttribute>().Selector == this.Selector)
.ToDictionary(p => p, p => p.IsDefined(typeof(DisplayAttribute)) ? p.GetCustomAttribute<DisplayAttribute>().Name : p.Name);
}
private string GetErrorMessage(int numberOfRequiredFields, IEnumerable<string> properties)
{
var errorMessage = string.Format(this.ErrorMessageString, numberOfRequiredFields);
if (this.IncludeOthersFieldName)
{
errorMessage += ": " + string.Join(", ", properties);
}
return errorMessage;
}
}

Comment l'utiliser dans votre modèle de vue?

Dans votre modèle, voici comment l'utiliser :

public class SomeViewModel
{
internal const string GroupOne = "Group1";
internal const string GroupTwo = "Group2";
[RequireFromGroupField(GroupOne)]
public bool IsA { get; set; }
[RequireFromGroupField(GroupOne)]
public bool IsB { get; set; }
[RequireFromGroupField(GroupOne)]
public bool IsC { get; set; }
//... other properties
[RequireFromGroupField(GroupTwo)]
public bool IsY { get; set; }
[RequireFromGroupField(GroupTwo)]
public bool IsZ { get; set; }
}

Par défaut, vous n'avez pas besoin de décorer votre modèle avec RequireFromGroupAttribute parce que le nombre par défaut des champs requis est de 1. Mais si vous voulez un certain nombre de champs à être différent de 1, vous pouvez effectuer les opérations suivantes :

[RequireFromGroup(GroupOne, Number = 2)]
public class SomeViewModel
{
//...
}

Comment l'utiliser dans votre code?

@model SomeViewModel
<script src="@Url.Content("~/Scripts/jquery.validate.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/require_from_group.js")" type="text/javascript"></script>
@using (Html.BeginForm())
{
@Html.CheckBoxFor(x => x.IsA, new { @class="Group1"})<span>A</span>
@Html.ValidationMessageFor(x => x.IsA)
<br />
@Html.CheckBoxFor(x => x.IsB, new { @class = "Group1" }) <span>B</span><br />
@Html.CheckBoxFor(x => x.IsC, new { @class = "Group1" }) <span>C</span><br />
@Html.CheckBoxFor(x => x.IsY, new { @class = "Group2" }) <span>Y</span>
@Html.ValidationMessageFor(x => x.IsY)
<br />
@Html.CheckBoxFor(x => x.IsZ, new { @class = "Group2" })<span>Z</span><br />
<input type="submit" value="OK" />
}

Avis de la sélection de groupe que vous avez spécifié lors de l'utilisation de RequireFromGroupField de l'attribut est à utiliser dans votre vue en spécifiant comme une classe dans chaque entrée impliqués dans vos groupes.

C'est tout pour le côté serveur de validation.

Nous allons parler de la validation côté client.

Si vous cochez la GetClientValidationRules mise en œuvre dans RequireFromGroupFieldAttribute classe, vous allez le voir, je suis l'aide de la chaîne requirefromgroup et pas require_from_group que le nom de la méthode pour la ValidationType de la propriété. C'est parce que ASP.Net MVC permet uniquement le nom du type de validation pour contenir alphanumérique char et ne doit pas commencer par un chiffre. Donc, vous devez ajouter le code javascript suivant :

$.validator.unobtrusive.adapters.add("requirefromgroup", ["number", "selector"], function (options) {
options.rules["require_from_group"] = [options.params.number, options.params.selector];
options.messages["require_from_group"] = options.message;
});

La partie javascript est très simple, parce que dans la mise en œuvre de l'adaptateur de la fonction nous venons de déléguer la validation de la correcte require_from_group méthode.

Car il fonctionne avec tous les types de input, textarea et select éléments, je pense que de cette façon est plus générique.

Espère que ça aide!

Pour info, je pense que vous pouvez éviter d'avoir à ajouter des classes les entrées dans votre balisage par la modification de l'attribut Sélecteur de propriété à un GroupIdentifier de la propriété. Puis dans GetClientValidationRules vous pouvez ajouter ceci: la règle.ValidationParameters.Add("groupe-identification", cette.GroupIdentifier); la règle.ValidationParameters.Add("sélecteur", "[data-groupe-identifiant=" + this.GroupIdentifier + "]");

InformationsquelleAutor CodeNotFound

J'ai mis en place Darin est génial de réponse à ma demande, sauf que j'ai ajouté pour les chaînes et non les valeurs booléennes. C'était pour des choses comme les nom/société, ou par téléphone/e-mail. Je l'ai aimé, sauf pour un mineur de pinailler.

J'ai essayé de les soumettre mon formulaire sans un téléphone, téléphone mobile, téléphone à la maison, ou e-mail. J'ai eu quatre erreurs de validation côté client. C'est bien pour moi, car il permet aux utilisateurs de savoir exactement dans quel domaine(s) peut être complétée pour faire disparaître l'erreur.

J'ai tapé une adresse e-mail. Maintenant, la seule validation en vertu de l'e-mail est allé loin, mais les trois sont restés sous les numéros de téléphone. Ces ne sont plus des erreurs de plus.

Donc, j'ai réassigné la méthode jQuery que des contrôles de validation pour tenir compte de cela. Le Code ci-dessous. Espérons que cela aide quelqu'un.

jQuery.validator.prototype.check = function (element) {
var elements = [];
elements.push(element);
var names;
while (elements.length > 0) {
element = elements.pop();
element = this.validationTargetFor(this.clean(element));
var rules = $(element).rules();
if ((rules.group) && (rules.group.propertynames) && (!names)) {
names = rules.group.propertynames.split(",");
names.splice($.inArray(element.name, names), 1);
var name;
while (name = names.pop()) {
elements.push($("#" + name));
}
}
var dependencyMismatch = false;
var val = this.elementValue(element);
var result;
for (var method in rules) {
var rule = { method: method, parameters: rules[method] };
try {
result = $.validator.methods[method].call(this, val, element, rule.parameters);
//if a method indicates that the field is optional and therefore valid,
//don't mark it as valid when there are no other rules
if (result === "dependency-mismatch") {
dependencyMismatch = true;
continue;
}
dependencyMismatch = false;
if (result === "pending") {
this.toHide = this.toHide.not(this.errorsFor(element));
return;
}
if (!result) {
this.formatAndAdd(element, rule);
return false;
}
} catch (e) {
if (this.settings.debug && window.console) {
console.log("Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.", e);
}
throw e;
}
}
if (dependencyMismatch) {
return;
}
if (this.objectLength(rules)) {
this.successList.push(element);
}
}
return true;
};

InformationsquelleAutor Paul

0

Je sais que c'est un vieux thread mais je viens de tomber sur le même scénario et trouvé quelques solutions et en a vu un qui résout Matt est question ci-dessus donc je pensais que je voudrais partager pour ceux qui viennent à travers cette réponse. Découvrez: MVC3 discret groupe de validation des entrées

InformationsquelleAutor Chris Searles

Vous devez vous connecter pour publier un commentaire.

Utilisation de require_from_group de jquery-équipe de validation: