Gérer la validation ModelState dans l'API Web ASP.NET

Je me demandais comment réaliser la validation de modèle avec l'API Web ASP.NET. J'ai mon modèle comme ça:

public class Enquiry
{
    [Key]
    public int EnquiryId { get; set; }
    [Required]
    public DateTime EnquiryDate { get; set; }
    [Required]
    public string CustomerAccountNumber { get; set; }
    [Required]
    public string ContactName { get; set; }
}

J'ai alors une action Post dans mon contrôleur API:

public void Post(Enquiry enquiry)
{
    enquiry.EnquiryDate = DateTime.Now;
    context.DaybookEnquiries.Add(enquiry);
    context.SaveChanges();
}

Comment ajouter if(ModelState.IsValid)puis gérer le message d'erreur à transmettre à l'utilisateur?

Pour séparer les préoccupations, je vous suggère d'utiliser un filtre d'action pour la validation du modèle, vous n'avez donc pas besoin de vous soucier de la façon de faire la validation dans votre contrôleur api:

using System.Net;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;

namespace System.Web.Http.Filters
{
    public class ValidationActionFilter : ActionFilterAttribute
    {
        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            var modelState = actionContext.ModelState;

            if (!modelState.IsValid)
                actionContext.Response = actionContext.Request
                     .CreateErrorResponse(HttpStatusCode.BadRequest, modelState);
        }
    }
}

Peut-être pas ce que vous cherchiez, mais peut-être agréable à savoir:

Si vous utilisez .net Web Api 2, procédez comme suit:

if (!ModelState.IsValid)
     return BadRequest(ModelState);

En fonction des erreurs du modèle, vous obtenez ce résultat:

{
   Message: "The request is invalid."
   ModelState: {
       model.PropertyA: [
            "The PropertyA field is required."
       ],
       model.PropertyB: [
             "The PropertyB field is required."
       ]
   }
}

Comme ceci, par exemple:

public HttpResponseMessage Post(Person person)
{
    if (ModelState.IsValid)
    {
        PersonDB.Add(person);
        return Request.CreateResponse(HttpStatusCode.Created, person);
    }
    else
    {
        // the code below should probably be refactored into a GetModelErrors
        // method on your BaseApiController or something like that

        var errors = new List<string>();
        foreach (var state in ModelState)
        {
            foreach (var error in state.Value.Errors)
            {
                errors.Add(error.ErrorMessage);
            }
        }
        return Request.CreateResponse(HttpStatusCode.Forbidden, errors);
    }
}

Cela renverra une réponse comme celle-ci (en supposant JSON, mais même principe de base pour XML):

HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
(some headers removed here)

["A value is required.","The field First is required.","Some custom errorm essage."]

Vous pouvez bien sûr construire votre objet / liste d'erreur comme vous le souhaitez, par exemple en ajoutant des noms de champ, des identifiants de champ, etc.

Même s'il s'agit d'un appel Ajax "à sens unique" comme un POST d'une nouvelle entité, vous devez quand même renvoyer quelque chose à l'appelant - quelque chose qui indique si la demande a réussi ou non. Imaginez un site où votre utilisateur ajoutera des informations sur lui-même via une requête AJAX POST. Que faire si les informations qu'ils ont essayé de saisir ne sont pas valides - comment sauront-ils si leur action Enregistrer a réussi ou non?

La meilleure façon de le faire est d'utiliser de bons vieux codes d'état HTTP comme 200 OKet ainsi de suite. De cette façon, votre JavaScript peut gérer correctement les échecs en utilisant les bons rappels (erreur, succès, etc.).

Voici un joli tutoriel sur une version plus avancée de cette méthode, utilisant un ActionFilter et jQuery: http://asp.net/web-api/videos/getting-started/custom-validation

Vous pouvez utiliser des attributs de l' System.ComponentModel.DataAnnotationsespace de noms pour définir des règles de validation. Référez-vous à la validation du modèle - Par Mike Wasson pour plus de détails.

Voir également la vidéo API Web ASP.NET, Partie 5: Validation personnalisée - Jon Galloway

Autres références

1. Promenez-vous côté client avec WebAPI et WebForms
2. Comment l'API Web ASP.NET lie les messages HTTP aux modèles de domaine et comment utiliser les formats multimédias dans l'API Web.
3. Dominick Baier - Sécurisation des API Web ASP.NET
4. Accrocher la validation AngularJS à la validation de l'API Web ASP.NET
5. Affichage des erreurs ModelState avec AngularJS dans ASP.NET MVC
6. Comment rendre les erreurs au client? AngularJS / WebApi ModelState
7. Validation injectée de dépendances dans l'API Web

Ou, si vous recherchez une simple collection d'erreurs pour vos applications ... voici ma mise en œuvre de ceci:

public override void OnActionExecuting(HttpActionContext actionContext)
    {
        var modelState = actionContext.ModelState;

        if (!modelState.IsValid) 
        {

            var errors = new List<string>();
            foreach (var state in modelState)
            {
                foreach (var error in state.Value.Errors)
                {
                    errors.Add(error.ErrorMessage);
                }
            }

            var response = new { errors = errors };

            actionContext.Response = actionContext.Request
                .CreateResponse(HttpStatusCode.BadRequest, response, JsonMediaTypeFormatter.DefaultMediaType);
        }
    }

La réponse au message d'erreur ressemblera à ceci:

{
  "errors": [
    "Please enter a valid phone number (7+ more digits)",
    "Please enter a valid e-mail address"
  ]
}

Ajouter le code ci-dessous dans le fichier startup.cs

services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2).ConfigureApiBehaviorOptions(options =>
            {
                options.InvalidModelStateResponseFactory = (context) =>
                {
                    var errors = context.ModelState.Values.SelectMany(x => x.Errors.Select(p => new ErrorModel()
                   {
                       ErrorCode = ((int)HttpStatusCode.BadRequest).ToString(CultureInfo.CurrentCulture),
                        ErrorMessage = p.ErrorMessage,
                        ServerErrorMessage = string.Empty
                    })).ToList();
                    var result = new BaseResponse
                    {
                        Error = errors,
                        ResponseCode = (int)HttpStatusCode.BadRequest,
                        ResponseMessage = ResponseMessageConstants.VALIDATIONFAIL,

                    };
                    return new BadRequestObjectResult(result);
                };
           });

Ici, vous pouvez vérifier pour afficher l'erreur d'état du modèle une par une

 public HttpResponseMessage CertificateUpload(employeeModel emp)
    {
        if (!ModelState.IsValid)
        {
            string errordetails = "";
            var errors = new List<string>();
            foreach (var state in ModelState)
            {
                foreach (var error in state.Value.Errors)
                {
                    string p = error.ErrorMessage;
                    errordetails = errordetails + error.ErrorMessage;

                }
            }
            Dictionary<string, object> dict = new Dictionary<string, object>();



            dict.Add("error", errordetails);
            return Request.CreateResponse(HttpStatusCode.BadRequest, dict);


        }
        else
        {
      //do something
        }
        }

}

C #

    public class ValidateModelAttribute : ActionFilterAttribute
    {
        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            if (actionContext.ModelState.IsValid == false)
            {
                actionContext.Response = actionContext.Request.CreateErrorResponse(
                    HttpStatusCode.BadRequest, actionContext.ModelState);
            }
        }
    }

...

    [ValidateModel]
    public HttpResponseMessage Post([FromBody]AnyModel model)
    {

Javascript

$.ajax({
        type: "POST",
        url: "/api/xxxxx",
        async: 'false',
        contentType: "application/json; charset=utf-8",
        data: JSON.stringify(data),
        error: function (xhr, status, err) {
            if (xhr.status == 400) {
                DisplayModelStateErrors(xhr.responseJSON.ModelState);
            }
        },
....


function DisplayModelStateErrors(modelState) {
    var message = "";
    var propStrings = Object.keys(modelState);

    $.each(propStrings, function (i, propString) {
        var propErrors = modelState[propString];
        $.each(propErrors, function (j, propError) {
            message += propError;
        });
        message += "\n";
    });

    alert(message);
};

J'ai eu un problème d'implémentation du modèle de solution accepté où mon ModelStateFilterretournait toujours false(et par la suite un 400) actionContext.ModelState.IsValidpour certains objets de modèle:

public class ModelStateFilter : ActionFilterAttribute
{
    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        if (!actionContext.ModelState.IsValid)
        {
            actionContext.Response = new HttpResponseMessage { StatusCode = HttpStatusCode.BadRequest};
        }
    }
}

J'accepte uniquement JSON, j'ai donc implémenté une classe de classeur de modèle personnalisée:

public class AddressModelBinder : System.Web.Http.ModelBinding.IModelBinder
{
    public bool BindModel(HttpActionContext actionContext, System.Web.Http.ModelBinding.ModelBindingContext bindingContext)
    {
        var posted = actionContext.Request.Content.ReadAsStringAsync().Result;
        AddressDTO address = JsonConvert.DeserializeObject<AddressDTO>(posted);
        if (address != null)
        {
            // moar val here
            bindingContext.Model = address;
            return true;
        }
        return false;
    }
}

Que j'inscris directement après mon modèle via

config.BindParameter(typeof(AddressDTO), new AddressModelBinder());

Vous pouvez également lever des exceptions comme indiqué ici: http://blogs.msdn.com/b/youssefm/archive/2012/06/28/error-handling-in-asp-net-webapi.aspx

Notez que pour faire ce que cet article suggère, n'oubliez pas d'inclure System.Net.Http