5624191041

Committed 21 Jul 2023 03:52PM UTC coverage: 95.754% (+0.3%) from 95.463%

Build # 5624191041

Build Type

push

github

Committed by

AndreuCodina

Commit Message

Publish main branch coverage

Run Details

405 of 446 branches covered (90.81%)

Branch coverage included in aggregate %.

1354 of 1391 relevant lines covered (97.34%)

180.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.36

/src/CrossValidation/DependencyInjection/CrossValidationMiddleware.cs

﻿using System.Net;
using System.Text.Json;
using CrossValidation.Exceptions;
using CrossValidation.Utils;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

namespace CrossValidation.DependencyInjection;

public class CrossValidationMiddleware : IMiddleware
{
    private readonly ILogger<CrossValidationMiddleware> _logger;
    private readonly IHostingEnvironment _environment;

    public CrossValidationMiddleware(ILoggerFactory loggerFactory, IHostingEnvironment environment)
    {
        _logger = loggerFactory.CreateLogger<CrossValidationMiddleware>();
        _environment = environment;
    }
    
    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        try
        {
            await next(context);
        }
        catch (Exception e)
        {
            await HandleException(e, context);
        }
    }

    private async Task HandleException(Exception exception, HttpContext context)
    {
        var problemDetails = new CrossProblemDetails();
        var statusCode = HttpStatusCode.InternalServerError;
        string? type = null;
        string? title = null;
        string? details = null;
        List<CrossProblemDetailsError> errors = new();
        
        if (exception is BusinessException businessException)
        {
            statusCode = businessException.StatusCode;
            title = "A validation error occurred";
            var error = CreateCrossProblemDetailsError(businessException);
            
            var allErrorCustomizationsAreNotSet =
                error is
                {
                    Code: null,
                    Message: null,
                    Details: null,
                    Placeholders: null
                };

            if (!allErrorCustomizationsAreNotSet)
            {
                errors.Add(error);
            }
        }
        else if (exception is BusinessListException validationListException)
        {
            statusCode = HttpStatusCode.UnprocessableEntity;
            title = "Several validation errors occurred";

            foreach (var error in validationListException.Exceptions)
            {
                errors.Add(CreateCrossProblemDetailsError(error));
            }
        }
        else if (exception is NonNullablePropertyIsNullException nonNullablePropertyIsNullException)
        {
            statusCode = HttpStatusCode.BadRequest;
            title = "Nullability error";
            details = $"Non nullable property is null: {nonNullablePropertyIsNullException.PropertyName}";
        }
        else if (exception is NonNullableItemCollectionWithNullItemException
                 nonNullableItemCollectionWithNullItemException)
        {
            statusCode = HttpStatusCode.BadRequest;
            title = "Nullability error";
            details = $"Non nullable item collection with null item: {nonNullableItemCollectionWithNullItemException.CollectionName}";
        }
        else
        {
            if (!CrossValidationOptions.HandleUnknownException)
            {
                return;
            }
            
            _logger.LogError(exception, exception.Message);
            type = "https://datatracker.ietf.org/doc/html/rfc9110#section-15.6.1";
            title = "An error occurred";
            problemDetails.Detail = _environment.IsDevelopment() ? exception.Message : null;
        }

        problemDetails.Status = (int)statusCode;
        problemDetails.Type = type;
        problemDetails.Title = title;
        problemDetails.Detail = details;
        problemDetails.Errors = errors.Any() ? errors : null;
        var response = JsonSerializer.Serialize(problemDetails);
        context.Response.StatusCode = problemDetails.Status.Value;
        context.Response.ContentType = "application/problem+json";
        context.Response.Headers.Add("X-Trace-Id", context.Request.Headers["X-Trace-Id"]);
        await context.Response.WriteAsync(response);
    }

    private CrossProblemDetailsError CreateCrossProblemDetailsError(BusinessException exception)
    {
        var error = new CrossProblemDetailsError
        {
            Code = exception.Code,
            Message = exception.Message == "" ? null : exception.Message,
            Details = exception.Details
        };

        if (exception is FrontBusinessException
            || (CrossValidationOptions.LocalizeCommonErrorsInFront
                && exception.PlaceholderValues.Count > 0))
        {
            var placeholders = new Dictionary<string, object?>();
            
            foreach (var placeholder in exception.PlaceholderValues)
            {
                placeholders.Add(placeholder.Key, placeholder.Value);
            }

            error.Placeholders = placeholders;
        }

        return error;
    }
}

1	using System.Net;
2	using System.Text.Json;
3	using CrossValidation.Exceptions;
4	using CrossValidation.Utils;
5	using Microsoft.AspNetCore.Hosting;
6	using Microsoft.AspNetCore.Http;
7	using Microsoft.Extensions.Logging;
8
9	namespace CrossValidation.DependencyInjection;
10
11	public class CrossValidationMiddleware : IMiddleware
12	{
13	private readonly ILogger<CrossValidationMiddleware> _logger;
14	private readonly IHostingEnvironment _environment;
15
16	public CrossValidationMiddleware(ILoggerFactory loggerFactory, IHostingEnvironment environment)	24✔
17	{
18	_logger = loggerFactory.CreateLogger<CrossValidationMiddleware>();	24✔
19	_environment = environment;	24✔
20	}	24✔
21
22	public async Task InvokeAsync(HttpContext context, RequestDelegate next)
23	{
24	try
25	{
26	await next(context);	24✔
27	}	×
28	catch (Exception e)	24✔
29	{
30	await HandleException(e, context);	24✔
31	}
32	}	24✔
33
34	private async Task HandleException(Exception exception, HttpContext context)
35	{
36	var problemDetails = new CrossProblemDetails();	24✔
37	var statusCode = HttpStatusCode.InternalServerError;	24✔
38	string? type = null;	24✔
39	string? title = null;	24✔
40	string? details = null;	24✔
41	List<CrossProblemDetailsError> errors = new();	24✔
42
43	if (exception is BusinessException businessException)	24✔
44	{
45	statusCode = businessException.StatusCode;	22✔
46	title = "A validation error occurred";	22✔
47	var error = CreateCrossProblemDetailsError(businessException);	22✔
48
49	var allErrorCustomizationsAreNotSet =	22✔
50	error is	22✔
51	{	22✔
52	Code: null,	22✔
53	Message: null,	22✔
54	Details: null,	22✔
55	Placeholders: null	22✔
56	};	22✔
57
58	if (!allErrorCustomizationsAreNotSet)	22✔
59	{
60	errors.Add(error);	19✔
61	}
62	}
63	else if (exception is BusinessListException validationListException)	2✔
64	{
65	statusCode = HttpStatusCode.UnprocessableEntity;	1✔
66	title = "Several validation errors occurred";	1✔
67
68	foreach (var error in validationListException.Exceptions)	2!
69	{
70	errors.Add(CreateCrossProblemDetailsError(error));	×
71	}
72	}
73	else if (exception is NonNullablePropertyIsNullException nonNullablePropertyIsNullException)	1!
74	{
75	statusCode = HttpStatusCode.BadRequest;	×
76	title = "Nullability error";	×
77	details = $"Non nullable property is null: {nonNullablePropertyIsNullException.PropertyName}";	×
78	}
79	else if (exception is NonNullableItemCollectionWithNullItemException	1!
80	nonNullableItemCollectionWithNullItemException)	1✔
81	{
82	statusCode = HttpStatusCode.BadRequest;	×
83	title = "Nullability error";	×
84	details = $"Non nullable item collection with null item: {nonNullableItemCollectionWithNullItemException.CollectionName}";	×
85	}
86	else
87	{
88	if (!CrossValidationOptions.HandleUnknownException)	1!
89	{
90	return;	×
91	}
92
93	_logger.LogError(exception, exception.Message);	1✔
94	type = "https://datatracker.ietf.org/doc/html/rfc9110#section-15.6.1";	1✔
95	title = "An error occurred";	1✔
96	problemDetails.Detail = _environment.IsDevelopment() ? exception.Message : null;	1!
97	}
98
99	problemDetails.Status = (int)statusCode;	24✔
100	problemDetails.Type = type;	24✔
101	problemDetails.Title = title;	24✔
102	problemDetails.Detail = details;	24✔
103	problemDetails.Errors = errors.Any() ? errors : null;	24✔
104	var response = JsonSerializer.Serialize(problemDetails);	24✔
105	context.Response.StatusCode = problemDetails.Status.Value;	24✔
106	context.Response.ContentType = "application/problem+json";	24✔
107	context.Response.Headers.Add("X-Trace-Id", context.Request.Headers["X-Trace-Id"]);	24✔
108	await context.Response.WriteAsync(response);	24✔
109	}	24✔
110
111	private CrossProblemDetailsError CreateCrossProblemDetailsError(BusinessException exception)
112	{
113	var error = new CrossProblemDetailsError	22✔
114	{	22✔
115	Code = exception.Code,	22✔
116	Message = exception.Message == "" ? null : exception.Message,	22✔
117	Details = exception.Details	22✔
118	};	22✔
119
120	if (exception is FrontBusinessException	22!
121	\|\| (CrossValidationOptions.LocalizeCommonErrorsInFront	22✔
122	&& exception.PlaceholderValues.Count > 0))	22✔
123	{
124	var placeholders = new Dictionary<string, object?>();	1✔
125
126	foreach (var placeholder in exception.PlaceholderValues)	6✔
127	{
128	placeholders.Add(placeholder.Key, placeholder.Value);	2✔
129	}
130
131	error.Placeholders = placeholders;	1✔
132	}
133
134	return error;	22✔
135	}
136	}

AndreuCodina / CrossValidation / 5624191041

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous