Modèle MVC exiger vrai

Je voudrais créer un validateur pour à la fois côté Serveur ET Client. En utilisant MVC et discrète de la validation du formulaire, cela peut être réalisé simplement en procédant de la manière suivante:

Tout d'abord, créer une classe dans votre projet pour effectuer le côté serveur de validation de la sorte:

public class EnforceTrueAttribute : ValidationAttribute, IClientValidatable
{
    public override bool IsValid(object value)
    {
        if (value == null) return false;
        if (value.GetType() != typeof(bool)) throw new InvalidOperationException("can only be used on boolean properties.");
        return (bool)value == true;
    }

    public override string FormatErrorMessage(string name)
    {
        return "The " + name + " field must be checked in order to continue.";
    }

    public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {
        yield return new ModelClientValidationRule
        {
            ErrorMessage = String.IsNullOrEmpty(ErrorMessage) ? FormatErrorMessage(metadata.DisplayName) : ErrorMessage,
            ValidationType = "enforcetrue"
        };
    }
}

Suite à cela, d'annoter la propriété appropriée dans votre modèle:

[EnforceTrue(ErrorMessage=@"Error Message")]
public bool ThisMustBeTrue{ get; set; }

Et Enfin, permettre la validation côté client en ajoutant le script suivant à votre Vue:

<script type="text/javascript">
    jQuery.validator.addMethod("enforcetrue", function (value, element, param) {
        return element.checked;
    });
    jQuery.validator.unobtrusive.adapters.addBool("enforcetrue");
</script>

Remarque: Nous avons déjà créé une méthode GetClientValidationRules qui pousse notre commentaire à la vue de notre modèle.

Si vous utilisez des fichiers de ressources pour fournir le message d'erreur pour l'internationalisation, la suppression de la FormatErrorMessage appel (ou il suffit d'appeler la base) et de modifier les GetClientValidationRules méthode comme suit:

public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
{
    string errorMessage = String.Empty;
    if(String.IsNullOrWhiteSpace(ErrorMessage))
    {
        //Check if they supplied an error message resource
        if(ErrorMessageResourceType != null && !String.IsNullOrWhiteSpace(ErrorMessageResourceName))
        {
            var resMan = new ResourceManager(ErrorMessageResourceType.FullName, ErrorMessageResourceType.Assembly);
            errorMessage = resMan.GetString(ErrorMessageResourceName);
        }
    }
    else
    {
        errorMessage = ErrorMessage;
    }

    yield return new ModelClientValidationRule
    {
        ErrorMessage = errorMessage,
        ValidationType = "enforcetrue"
    };
}

J'ai essayé plusieurs solutions mais aucune n'a fonctionné complètement pour moi d'obtenir à la fois côté client et serveur de validation. Donc, ce que j'ai fait dans mon MVC 5 application pour le faire fonctionner:

Dans votre ViewModel (pour le côté serveur de validation):

public bool IsTrue => true;

[Required]
[Display(Name = "I agree to the terms and conditions")]
[Compare(nameof(IsTrue), ErrorMessage = "Please agree to Terms and Conditions")]
public bool HasAcceptedTermsAndConditions { get; set; }

Dans votre Rasoir page (pour la validation côté client):

<div class="form-group">
   @Html.CheckBoxFor(m => m.HasAcceptedTermsAndConditions)
   @Html.LabelFor(m => m.HasAcceptedTermsAndConditions)
   @Html.ValidationMessageFor(m => m.HasAcceptedTermsAndConditions)

   @Html.Hidden(nameof(Model.IsTrue), "true")
</div>

Juste vérifier pour voir si sa représentation sous forme de chaîne est égale à True:

[RegularExpression("True")]
public bool TermsAndConditions { get; set; }

[Required] attribut représente nécessitant tout valeur, il peut être vrai ou faux. Vous auriez à utiliser une autre validation pour que.

Pour ASP.NET Core, MVC voici validation client et serveur, basée sur dazbradbury la solution de

public class EnforceTrueAttribute : ValidationAttribute, IClientModelValidator
{
    public override bool IsValid(object value)
    {
        if (value == null) return false;
        if (value.GetType() != typeof(bool)) throw new InvalidOperationException("can only be used on boolean properties.");
        return (bool)value;
    }

    public void AddValidation(ClientModelValidationContext context)
    {
        MergeAttribute(context.Attributes, "data-val", "true");
        var errorMessage = ErrorMessage ?? 
            $"The value for field {context.ModelMetadata.GetDisplayName()} must be true.";
        MergeAttribute(context.Attributes, "data-val-enforcetrue", errorMessage);
    }

    private void MergeAttribute(IDictionary<string, string> attributes,
        string key,
        string value)
    {
        if (attributes.ContainsKey(key))
        {
            return;
        }
        attributes.Add(key, value);
    }
}

Puis sur le client:

$.validator.addMethod("enforcetrue", function (value, element, param) {
    return element.checked;
});

$.validator.unobtrusive.adapters.addBool("enforcetrue");

Alors d'usage:

[EnforceTrue(ErrorMessage = "Please tick the checkbox")]
public bool IsAccepted { get; set; }

Je ne sais pas d'un chemin à travers DataAnnotations, mais c'est facile à faire dans votre contrôleur.

public ActionResult Add(Domain.Something model)
{

    if (!model.MyCheckBox)
        ModelState.AddModelError("MyCheckBox", "You forgot to click accept");

    if (ModelState.IsValid) {
        //'# do your stuff
    }

}

La seule autre option serait de construire un validateur personnalisé pour la partie serveur et une distance validateur pour le côté client (validation à distance n'est disponible que dans MVC3+)

Je pense que la meilleure façon de gérer cela est juste vérifier dans votre contrôleur si la case est vrai sinon il suffit d'ajouter une erreur à votre modèle et l'ont réafficher votre point de vue.

Comme dit précédemment, tous les [Obligatoire] n'est assurez-vous qu'il est une valeur et, dans votre cas, pas cochée, vous obtenez toujours faux.

///<summary> 
/// Summary : -CheckBox for or input type check required validation is not working the root cause and solution as follows
///
/// Problem :
/// The key to this problem lies in interpretation of jQuery validation 'required' rule. I digged a little and find a specific code inside a jquery.validate.unobtrusive.js file:
/// adapters.add("required", function (options) {
/// if (options.element.tagName.toUpperCase() !== "INPUT" || options.element.type.toUpperCase() !== "CHECKBOX") {
///   setValidationValues(options, "required", true);
///   }
///  });
///  
/// Fix: (Jquery script fix at page level added in to check box required area)
/// jQuery.validator.unobtrusive.adapters.add("brequired", function (options) {
///  if (options.element.tagName.toUpperCase() == "INPUT" && options.element.type.toUpperCase() == "CHECKBOX") {
///             options.rules["required"] = true;
///  if (options.message) {
///                  options.messages["required"] = options.message;
///                      }
/// Fix : (C# Code for MVC validation)
/// You can see it inherits from common RequiredAttribute. Moreover it implements IClientValidateable. This is to make assure that rule will be propagated to client side (jQuery validation) as well.
/// 
/// Annotation example :
///  [BooleanRequired]
///  public bool iAgree { get; set' }
///</summary>


public class BooleanRequired : RequiredAttribute, IClientValidatable
{

    public BooleanRequired()
    {
    }

    public override bool IsValid(object value)
    {
        return value != null && (bool)value == true;
    }

    public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {
        return new ModelClientValidationRule[] { new ModelClientValidationRule() { ValidationType = "brequired", ErrorMessage = this.ErrorMessage } };
    }
}