How to deserialize 422 unprocessable entity error model and bind the errors to asp.net core razor pages model state

Question

My Asp.Net Core 3.1 API returns 422 Unprocessable Entity error response as shown below:

{
  "type": "https://test.com/modelvalidationproblem",
  "title": "One or more model validation errors occurred.",
  "status": 422,
  "detail": "See the errors property for details.",
  "instance": "/api/path",
  "traceId": "8000003f-0001-ec00-b63f-84710c7967bb",
  "errors": {
    "FirstName": [
      "The FirstName field is required."
    ]
  }
}

How to deserialize this response and add the errors to model validation error in Asp.Net Core 3.1 Razor Pages?

I tried to create model as shown below,

Error Model:

public class UnprocessableEntity
{
    public string Type { get; set; }
    public string Title { get; set; }
    public int Status { get; set; }
    public string Detail { get; set; }
    public string Instance { get; set; }
    public string TraceId { get; set; }
    public Errors Errors { get; set; }
}

public class Errors
{
    ....// what should I need to add here? Keys and messages will be dynamic
}

However what I should add inside Errors class? The error keys and messages will be dynamic.

Once above things is known, I can add model state errors in my razor pages as shown below,

using var responseStream = await response.Content.ReadAsStreamAsync();
var errorResponse = await JsonSerializer.DeserializeAsync<UnprocessableEntity>(responseStream);

foreach (var error in errorResponse.errors)
{
    ModelState.AddModelError(error.key, error.Message[0]); // I'm stuck here
}

score 2 · Accepted Answer · answered Mar 30 '20 at 07:35

First, you should ensure the key field names are the same as the json returned from api(pay attention to case).

 public class UnprocessableEntity
{
    public string type { get; set; }
    public string tTitle { get; set; }
    public int status { get; set; }
    public string detail { get; set; }
    public string instance { get; set; }
    public string traceId { get; set; }
    public Errors errors { get; set; }
}

Then, the fields of the Errors class should contain all the fields of the validated class, and the field names should be consistent, but you need to define their type as an array to receive, because each field returned by errors in json is an array. (here i created a simple validated class named StudInfo):

    public class StudInfo
    {
        [Key]
        public int Id { get; set; }
        [Required]
        public string Name { get; set; }
    }


    public class Errors
    {
        public List<string> Id { get; set; }
        public List<string> Name { get; set; }
    }

Then the code you can use as follow:

       using var responseStream = await response.Content.ReadAsStreamAsync();
       var errorResponse = await JsonSerializer.DeserializeAsync<UnprocessableEntity>(responseStream);
        var t = typeof(Errors);
        var fieldNames = typeof(Errors).GetProperties()
                        .Select(field => field.Name)
                        .ToList();
        foreach (var name in fieldNames)
        {
            List<string> errorLists = (List<string>)errorResponse.errors.GetType().GetProperty(name).GetValue(errorResponse.errors);
            if (errorLists != null)
            {
                ModelState.AddModelError(name, errorLists[0]); 
            }

        }

score 0 · Answer 2 · answered May 03 '20 at 18:41

I have modified @Yongqing Yu answer and made it generic.

422 Error Model:

public class UnprocessableEntity<T>
{
    [JsonPropertyName("type")]
    public string Type { get; set; }

    [JsonPropertyName("title")]
    public string Title { get; set; }

    [JsonPropertyName("status")]
    public int Status { get; set; }

    [JsonPropertyName("detail")]
    public string Detail { get; set; }

    [JsonPropertyName("instance")]
    public string Instance { get; set; }

    [JsonPropertyName("traceId")]
    public string TraceId { get; set; }

    [JsonPropertyName("errors")]
    public T Errors { get; set; }
}

Model:

public class EventRegisterViewModel
{
    [Required]
    [MaxLength(200)]
    [RegularExpression(ValidationConstants.ALPHABETSWITHSPACE, ErrorMessage = "Enter only alphabets")]
    [Display(Name = "First Name")]
    public string FirstName { get; set; }

    [Required]
    [MaxLength(200)]
    [RegularExpression(ValidationConstants.ALPHABETSWITHSPACE, ErrorMessage = "Enter only alphabets")]
    [Display(Name = "Last Name")]
    public string LastName { get; set; }

    [MinLength(10, ErrorMessage = "Please Enter 10 digit Mobile Number")]
    [MaxLength(10)]
    [RegularExpression(ValidationConstants.NUMBERSONLY, ErrorMessage = "Invalid Mobile Number")]
    [Display(Name = "Mobile Number")]
    public string MobileNumber { get; set; }

    [Required]
    [MaxLength(200)]
    [EmailAddress]
    [Display(Name = "Email Address")]
    public string EmailAddress { get; set; }
}

Error Model:

public class EventRegistrationValidationErrors
{
    public IEnumerable<string> FirstName { get; set; }
    public IEnumerable<string> LastName { get; set; }
    public IEnumerable<string> MobileNumber { get; set; }
    public IEnumerable<string> EmailAddress { get; set; }
}

While deserialzing,

using var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
var errorResponse = await JsonSerializer.DeserializeAsync<UnprocessableEntity<EventRegistrationValidationErrors>>(responseStream).ConfigureAwait(false);
var errorFieldNames = typeof(EventRegistrationValidationErrors)
                        .GetProperties()
                        .Select(field => field.Name)
                        .ToList();

foreach (var errorField in errorFieldNames)
{
    var errorLists = (List<string>)errorResponse.errors
                        .GetType()
                        .GetProperty(errorField)
                        .GetValue(errorResponse.errors);

    if (!(errorLists is null))
    {
        ModelState.AddModelError($"Event.{errorField}", errorLists[0]);
    }
}

Hope this helps someone out there.

How to deserialize 422 unprocessable entity error model and bind the errors to asp.net core razor pages model state

2 Answers2