.NET Starter Kit

Business Rule Validation

Validate PublicationYear

In addition to basic request validation, it is common to validate business rules against static values or values from database.

Let’s validate that PublicationYear has a minimum value of 1900 and max value of current year.

[HttpPost]
public IActionResult Create(CreateBookRequest request)
{
    logger.LogInformation("BookController.Create - Request {@request}", request");

    if (request.PublicationYear < 1900 || request.PublicationYear > DateTime.UtcNow.Year)
    {
        throw new ValidationException("Publication Year must be between 1990 and 2025");
    }

    //...
}

Test the API, the response is not consumable by frontend or mobile to show a readable message.

To get a similar response as basic validation, we can introduce an error middleware.

{
  "title": "",
  "status": "",
  "errors": ""
}

Add ErrorMiddleware

First, add Newtonsoft nuget package, it’s used to serialise objects into JSON and vice versa.

Next, in Dtos folder, add ErrorResponse.cs

public class ErrorResponse
{
    public string Title { get; set; }
    public int Status  { get; set; }
    public Dictionary<string, List<string>> Errors { get; set; }


    public ErrorResponse(int code, string message)
    {
        Title = message;
        Status = code;
        Errors = new Dictionary<string, List<string>>();
    }

}

In Utilities folder, add ErrorMiddleware.cs

public class ErrorMiddleware
{
    private readonly RequestDelegate _next;

    public ErrorMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }

    private Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        //exception = exception.Get();

        var statusCode = HttpStatusCode.InternalServerError;
        if (exception is ValidationException)
        {
            Log.Information(exception.Message);
            statusCode = HttpStatusCode.UnprocessableContent;
        }
        else if (exception is AuthenticationException)
        {
            Log.Error(exception.Message);
            statusCode = HttpStatusCode.Unauthorized;
        }
        else
        {
            Log.Fatal(exception.Message);
            Log.Fatal(exception.StackTrace);
        }

        var camelCaseSerializerSettings = new JsonSerializerSettings
        {
            ContractResolver = new CamelCasePropertyNamesContractResolver()
        };

        var errorResponse = new ErrorResponse((int)statusCode, exception.Message);
        var result = JsonConvert.SerializeObject(errorResponse, camelCaseSerializerSettings);

        context.Response.ContentType = "application/json";
        context.Response.StatusCode = (int)400;
        return context.Response.WriteAsync(result);
    }
}

In Program.cs, add

//...

app.UseMiddleware(typeof(ErrorMiddleware)); //add this

app.MapControllers();

//...