1899510545

Build Type

github

Committed by GitHub

Commit Message

Merge c197024e1 into bcfbee975

Pull Request Pull Request #20: OpenApi enhancements

Run Details

370 of 532 branches covered (69.55%)

Branch coverage included in aggregate %.

122 of 127 new or added lines in 5 files covered. (96.06%)

1 existing line in 1 file now uncovered.

1721 of 1850 relevant lines covered (93.03%)

34988.01 hits per line

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

81.25

/src/Futurum.WebApiEndpoint/OpenApi/WebApiEndpointOpenApiOperationFilter.cs

using Futurum.Core.Functional;
using Futurum.Core.Option;
using Futurum.WebApiEndpoint.Metadata;

using Microsoft.OpenApi.Models;

using Swashbuckle.AspNetCore.SwaggerGen;

namespace Futurum.WebApiEndpoint.OpenApi;

internal class WebApiEndpointOpenApiOperationFilter : IOperationFilter
{
    private readonly IWebApiEndpointMetadataCache _metadataCache;

    public WebApiEndpointOpenApiOperationFilter(IWebApiEndpointMetadataCache metadataCache)
    {
        _metadataCache = metadataCache;
    }

    public void Apply(OpenApiOperation openApiOperation, OperationFilterContext operationFilterContext)
    {
        if (operationFilterContext.ApiDescription.HttpMethod == MetadataRouteHttpMethod.Get.ToString() && openApiOperation.RequestBody != null)
        {
            openApiOperation.RequestBody.Required = false;
        }

        _metadataCache.Get(new WebApiEndpointMetadataCacheKey(operationFilterContext.ApiDescription.HttpMethod, operationFilterContext.ApiDescription.RelativePath))
                      .DoSwitch(metadataDefinition =>
                                {
                                    if (metadataDefinition.MetadataTypeDefinition.RequestDtoType == typeof(RequestUploadFilesDto))
                                    {
                                        ConfigureRequestUploadFilesDto(openApiOperation);
                                    }
                                    else if (metadataDefinition.MetadataMapFromMultipartDefinition != null)
                                    {
                                        ConfigureMultipart(openApiOperation, metadataDefinition.MetadataMapFromMultipartDefinition);
                                    }
                                    else
                                    {
                                        ConfigureParameters(openApiOperation, metadataDefinition);
                                    }

                                    UpdateOpenApiOperationInformation(openApiOperation, metadataDefinition);
                                },
                                Function.DoNothing);
    }

    private static void ConfigureRequestUploadFilesDto(OpenApiOperation openApiOperation)
    {
        void Execute(KeyValuePair<string, OpenApiMediaType> content)
        {
            content.Value.Schema = new OpenApiSchema
            {
                Type = "object",
                Required = new HashSet<string> { nameof(RequestUploadFilesDto.Files) },
                Properties = new Dictionary<string, OpenApiSchema>
                {
                    {
                        nameof(RequestUploadFilesDto.Files), MapDotnetTypesToOpenApiTypes(typeof(IEnumerable<IFormFile>))
                    }
                }
            };
        }

        openApiOperation.RequestBody.Content.TrySingle(x => x.Key == "multipart/form-data")
                        .Do(x => x.DoSwitch(Execute, Function.DoNothing));
    }

    private static void ConfigureMultipart(OpenApiOperation openApiOperation, MetadataMapFromMultipartDefinition metadataMapFromMultipartDefinition)
    {
        void Execute(KeyValuePair<string, OpenApiMediaType> content)
        {
            var multipartParameterDefinitions = metadataMapFromMultipartDefinition.MapFromMultipartParameterDefinitions;
            content.Value.Schema = new OpenApiSchema
            {
                Type = "object",
                Required = new HashSet<string>(multipartParameterDefinitions.Select(x => x.Name)),
                Properties = multipartParameterDefinitions.Select(mapFromMultipartParameterDefinition =>
                                                          {
                                                              var openApiSchema = MapDotnetTypesToOpenApiTypes(mapFromMultipartParameterDefinition.PropertyInfo.PropertyType);

                                                              return (mapFromMultipartParameterDefinition.Name, OpenApiSchema: openApiSchema);
                                                          })
                                                          .ToDictionary(x => x.Name, x => x.OpenApiSchema)
            };
        }

        openApiOperation.RequestBody.Content.TrySingle(x => x.Key == "multipart/form-data")
                        .Do(x => x.DoSwitch(Execute, Function.DoNothing));
    }

    private static void ConfigureParameters(OpenApiOperation openApiOperation, MetadataDefinition metadataDefinition)
    {
        if (metadataDefinition.MetadataRouteDefinition.ManualParameterDefinitions.Any())
        {
            var openApiParameters = GetOpenApiParametersForManualParameterDefinitions(metadataDefinition.MetadataRouteDefinition.ManualParameterDefinitions);

            foreach (var openApiParameter in openApiParameters)
            {
                openApiOperation.Parameters.Add(openApiParameter);
            }
        }

        if (metadataDefinition.MetadataMapFromDefinition != null)
        {
            var openApiParameters = GetOpenApiParametersForMapFrom(metadataDefinition.MetadataMapFromDefinition);

            foreach (var openApiParameter in openApiParameters)
            {
                openApiOperation.Parameters.Add(openApiParameter);
            }
        }
    }

    private static IEnumerable<OpenApiParameter> GetOpenApiParametersForManualParameterDefinitions(IEnumerable<MetadataRouteParameterDefinition> metadataRouteParameterDefinitions)
    {
        ParameterLocation TransformMetadataRouteParameterDefinitionTypeToOpenApiParameterLocation(MetadataRouteParameterDefinitionType parameterDefinitionType) =>
            parameterDefinitionType switch
            {
                MetadataRouteParameterDefinitionType.Path   => ParameterLocation.Path,
                MetadataRouteParameterDefinitionType.Query  => ParameterLocation.Query,
                MetadataRouteParameterDefinitionType.Cookie => ParameterLocation.Cookie,
                MetadataRouteParameterDefinitionType.Header => ParameterLocation.Header,
                _                                           => throw new ArgumentOutOfRangeException(nameof(parameterDefinitionType), parameterDefinitionType, null)
            };

        return metadataRouteParameterDefinitions.Select(parameterDefinition => new OpenApiParameter
        {
            Name = parameterDefinition.Name,
            Schema = MapDotnetTypesToOpenApiTypes(parameterDefinition.Type),
            Required = true,
            In = TransformMetadataRouteParameterDefinitionTypeToOpenApiParameterLocation(parameterDefinition.ParameterDefinitionType),
        });
    }

    private static IEnumerable<OpenApiParameter> GetOpenApiParametersForMapFrom(MetadataMapFromDefinition metadataRouteParameterDefinitions)
    {
        ParameterLocation TransformMetadataRouteParameterDefinitionTypeToOpenApiParameterLocation(MapFrom mapFrom) =>
            mapFrom switch
            {
                MapFrom.Path   => ParameterLocation.Path,
                MapFrom.Query  => ParameterLocation.Query,
                MapFrom.Cookie => ParameterLocation.Cookie,
                MapFrom.Header => ParameterLocation.Header,
                _              => throw new ArgumentOutOfRangeException(nameof(mapFrom), mapFrom, null)
            };

        return metadataRouteParameterDefinitions.MapFromParameterDefinitions
                                                .Select(parameterDefinition => new OpenApiParameter
                                                {
                                                    Name = parameterDefinition.Name,
                                                    Schema = MapDotnetTypesToOpenApiTypes(parameterDefinition.PropertyInfo.PropertyType),
                                                    Required = true,
                                                    In = TransformMetadataRouteParameterDefinitionTypeToOpenApiParameterLocation(parameterDefinition.MapFromAttribute.MapFrom),
                                                });
    }

    private static void UpdateOpenApiOperationInformation(OpenApiOperation openApiOperation, MetadataDefinition metadataDefinition)
    {
        openApiOperation.Summary = metadataDefinition.MetadataRouteDefinition.OpenApiOperation?.Summary;
        openApiOperation.Description = metadataDefinition.MetadataRouteDefinition.OpenApiOperation?.Description;
    }

    private static OpenApiSchema MapDotnetTypesToOpenApiTypes(Type type)
    {
        if (type == typeof(string))
        {
            return new OpenApiSchema { Type = "string" };
        }

        if (type == typeof(int))
        {
            return new OpenApiSchema { Type = "integer", Format = "int32" };
        }

        if (type == typeof(long))
        {
            return new OpenApiSchema { Type = "integer", Format = "int64" };
        }

        if (type == typeof(float))
        {
            return new OpenApiSchema { Type = "number", Format = "float" };
        }

        if (type == typeof(double))
        {
            return new OpenApiSchema { Type = "number", Format = "double" };
        }

        if (type == typeof(DateTime))
        {
            return new OpenApiSchema { Type = "string", Format = "date-time" };
        }

        if (type == typeof(IFormFile))
        {
            return new OpenApiSchema { Type = "string", Format = "binary" };
        }

        if (type == typeof(IEnumerable<IFormFile>))
        {
            return new OpenApiSchema { Type = "array", Items = new OpenApiSchema { Type = "string", Format = "binary" } };
        }

        if (type.IsClass && !type.IsPrimitive)
        {
            return new OpenApiSchema
            {
                Type = "object",
                Properties = type.GetProperties()
                                 .Select(x => (x.Name, propertyOpenApiSchema: MapDotnetTypesToOpenApiTypes(x.PropertyType)))
                                 .ToDictionary(x => x.Name, x => x.propertyOpenApiSchema)
            };
        }

        return null;
    }
}

1	using Futurum.Core.Functional;
2	using Futurum.Core.Option;
3	using Futurum.WebApiEndpoint.Metadata;
4
5	using Microsoft.OpenApi.Models;
6
7	using Swashbuckle.AspNetCore.SwaggerGen;
8
9	namespace Futurum.WebApiEndpoint.OpenApi;
10
11	internal class WebApiEndpointOpenApiOperationFilter : IOperationFilter
12	{
13	private readonly IWebApiEndpointMetadataCache _metadataCache;
14
15	public WebApiEndpointOpenApiOperationFilter(IWebApiEndpointMetadataCache metadataCache)	26✔
16	{	26✔
17	_metadataCache = metadataCache;	26✔
18	}	26✔
19
20	public void Apply(OpenApiOperation openApiOperation, OperationFilterContext operationFilterContext)
21	{	5✔
22	if (operationFilterContext.ApiDescription.HttpMethod == MetadataRouteHttpMethod.Get.ToString() && openApiOperation.RequestBody != null)	5!
23	{	×
24	openApiOperation.RequestBody.Required = false;	×
25	}	×
26
27	_metadataCache.Get(new WebApiEndpointMetadataCacheKey(operationFilterContext.ApiDescription.HttpMethod, operationFilterContext.ApiDescription.RelativePath))	5✔
28	.DoSwitch(metadataDefinition =>	5✔
29	{	5✔
30	if (metadataDefinition.MetadataTypeDefinition.RequestDtoType == typeof(RequestUploadFilesDto))	5✔
31	{	2✔
32	ConfigureRequestUploadFilesDto(openApiOperation);	2✔
33	}	2✔
34	else if (metadataDefinition.MetadataMapFromMultipartDefinition != null)	3✔
35	{	1✔
36	ConfigureMultipart(openApiOperation, metadataDefinition.MetadataMapFromMultipartDefinition);	1✔
37	}	1✔
38	else	5✔
39	{	2✔
40	ConfigureParameters(openApiOperation, metadataDefinition);	2✔
41	}	2✔
42		5✔
43	UpdateOpenApiOperationInformation(openApiOperation, metadataDefinition);	5✔
44	},	5✔
45	Function.DoNothing);	5✔
46	}	5✔
47
48	private static void ConfigureRequestUploadFilesDto(OpenApiOperation openApiOperation)
49	{	2✔
50	void Execute(KeyValuePair<string, OpenApiMediaType> content)
51	{	2✔
52	content.Value.Schema = new OpenApiSchema	2✔
53	{	2✔
54	Type = "object",	2✔
55	Required = new HashSet<string> { nameof(RequestUploadFilesDto.Files) },	2✔
56	Properties = new Dictionary<string, OpenApiSchema>	2✔
57	{	2✔
58	{	2✔
59	nameof(RequestUploadFilesDto.Files), MapDotnetTypesToOpenApiTypes(typeof(IEnumerable<IFormFile>))	2✔
60	}	2✔
61	}	2✔
62	};	2✔
63	}	2✔
64
65	openApiOperation.RequestBody.Content.TrySingle(x => x.Key == "multipart/form-data")	4✔
66	.Do(x => x.DoSwitch(Execute, Function.DoNothing));	4✔
67	}	2✔
68
69	private static void ConfigureMultipart(OpenApiOperation openApiOperation, MetadataMapFromMultipartDefinition metadataMapFromMultipartDefinition)
70	{	1✔
71	void Execute(KeyValuePair<string, OpenApiMediaType> content)
72	{	1✔
73	var multipartParameterDefinitions = metadataMapFromMultipartDefinition.MapFromMultipartParameterDefinitions;	1✔
74	content.Value.Schema = new OpenApiSchema	1✔
75	{	1✔
76	Type = "object",	1✔
77	Required = new HashSet<string>(multipartParameterDefinitions.Select(x => x.Name)),	2✔
78	Properties = multipartParameterDefinitions.Select(mapFromMultipartParameterDefinition =>	1✔
79	{	2✔
80	var openApiSchema = MapDotnetTypesToOpenApiTypes(mapFromMultipartParameterDefinition.PropertyInfo.PropertyType);	2✔
81		1✔
82	return (mapFromMultipartParameterDefinition.Name, OpenApiSchema: openApiSchema);	2✔
83	})	2✔
84	.ToDictionary(x => x.Name, x => x.OpenApiSchema)	4✔
85	};	1✔
86	}	1✔
87
88	openApiOperation.RequestBody.Content.TrySingle(x => x.Key == "multipart/form-data")	2✔
89	.Do(x => x.DoSwitch(Execute, Function.DoNothing));	2✔
90	}	1✔
91
92	private static void ConfigureParameters(OpenApiOperation openApiOperation, MetadataDefinition metadataDefinition)
93	{	2✔
94	if (metadataDefinition.MetadataRouteDefinition.ManualParameterDefinitions.Any())	2✔
95	{	1✔
96	var openApiParameters = GetOpenApiParametersForManualParameterDefinitions(metadataDefinition.MetadataRouteDefinition.ManualParameterDefinitions);	1✔
97
98	foreach (var openApiParameter in openApiParameters)	5✔
99	{	1✔
100	openApiOperation.Parameters.Add(openApiParameter);	1✔
101	}	1✔
102	}	1✔
103
104	if (metadataDefinition.MetadataMapFromDefinition != null)	2✔
105	{	1✔
106	var openApiParameters = GetOpenApiParametersForMapFrom(metadataDefinition.MetadataMapFromDefinition);	1✔
107
108	foreach (var openApiParameter in openApiParameters)	5✔
109	{	1✔
110	openApiOperation.Parameters.Add(openApiParameter);	1✔
111	}	1✔
112	}	1✔
113	}	2✔
114
115	private static IEnumerable<OpenApiParameter> GetOpenApiParametersForManualParameterDefinitions(IEnumerable<MetadataRouteParameterDefinition> metadataRouteParameterDefinitions)
116	{	1✔
117	ParameterLocation TransformMetadataRouteParameterDefinitionTypeToOpenApiParameterLocation(MetadataRouteParameterDefinitionType parameterDefinitionType) =>
118	parameterDefinitionType switch	1!
119	{	1✔
120	MetadataRouteParameterDefinitionType.Path => ParameterLocation.Path,	1✔
121	MetadataRouteParameterDefinitionType.Query => ParameterLocation.Query,	×
122	MetadataRouteParameterDefinitionType.Cookie => ParameterLocation.Cookie,	×
123	MetadataRouteParameterDefinitionType.Header => ParameterLocation.Header,	×
124	_ => throw new ArgumentOutOfRangeException(nameof(parameterDefinitionType), parameterDefinitionType, null)	×
125	};	1✔
126
127	return metadataRouteParameterDefinitions.Select(parameterDefinition => new OpenApiParameter	2✔
128	{	2✔
129	Name = parameterDefinition.Name,	2✔
130	Schema = MapDotnetTypesToOpenApiTypes(parameterDefinition.Type),	2✔
131	Required = true,	2✔
132	In = TransformMetadataRouteParameterDefinitionTypeToOpenApiParameterLocation(parameterDefinition.ParameterDefinitionType),	2✔
133	});	2✔
134	}	1✔
135
136	private static IEnumerable<OpenApiParameter> GetOpenApiParametersForMapFrom(MetadataMapFromDefinition metadataRouteParameterDefinitions)
137	{	1✔
138	ParameterLocation TransformMetadataRouteParameterDefinitionTypeToOpenApiParameterLocation(MapFrom mapFrom) =>
139	mapFrom switch	1!
140	{	1✔
141	MapFrom.Path => ParameterLocation.Path,	1✔
NEW 142	MapFrom.Query => ParameterLocation.Query,	×
NEW 143	MapFrom.Cookie => ParameterLocation.Cookie,	×
NEW 144	MapFrom.Header => ParameterLocation.Header,	×
NEW 145	_ => throw new ArgumentOutOfRangeException(nameof(mapFrom), mapFrom, null)	×
146	};	1✔
147
148	return metadataRouteParameterDefinitions.MapFromParameterDefinitions	1✔
149	.Select(parameterDefinition => new OpenApiParameter	2✔
150	{	2✔
151	Name = parameterDefinition.Name,	2✔
152	Schema = MapDotnetTypesToOpenApiTypes(parameterDefinition.PropertyInfo.PropertyType),	2✔
153	Required = true,	2✔
154	In = TransformMetadataRouteParameterDefinitionTypeToOpenApiParameterLocation(parameterDefinition.MapFromAttribute.MapFrom),	2✔
155	});	2✔
156	}	1✔
157
158	private static void UpdateOpenApiOperationInformation(OpenApiOperation openApiOperation, MetadataDefinition metadataDefinition)
159	{	5✔
160	openApiOperation.Summary = metadataDefinition.MetadataRouteDefinition.OpenApiOperation?.Summary;	5✔
161	openApiOperation.Description = metadataDefinition.MetadataRouteDefinition.OpenApiOperation?.Description;	5✔
162	}	5✔
163
164	private static OpenApiSchema MapDotnetTypesToOpenApiTypes(Type type)
165	{	7✔
166	if (type == typeof(string))	7✔
167	{	3✔
168	return new OpenApiSchema { Type = "string" };	3✔
169	}
170
171	if (type == typeof(int))	4!
172	{	×
173	return new OpenApiSchema { Type = "integer", Format = "int32" };	×
174	}
175
176	if (type == typeof(long))	4!
177	{	×
178	return new OpenApiSchema { Type = "integer", Format = "int64" };	×
179	}
180
181	if (type == typeof(float))	4!
182	{	×
183	return new OpenApiSchema { Type = "number", Format = "float" };	×
184	}
185
186	if (type == typeof(double))	4!
187	{	×
188	return new OpenApiSchema { Type = "number", Format = "double" };	×
189	}
190
191	if (type == typeof(DateTime))	4!
192	{	×
NEW 193	return new OpenApiSchema { Type = "string", Format = "date-time" };	×
194	}
195
196	if (type == typeof(IFormFile))	4✔
197	{	1✔
198	return new OpenApiSchema { Type = "string", Format = "binary" };	1✔
199	}
200
201	if (type == typeof(IEnumerable<IFormFile>))	3✔
202	{	2✔
203	return new OpenApiSchema { Type = "array", Items = new OpenApiSchema { Type = "string", Format = "binary" } };	2✔
204	}
205
206	if (type.IsClass && !type.IsPrimitive)	1!
207	{	1✔
208	return new OpenApiSchema	1✔
209	{	1✔
210	Type = "object",	1✔
211	Properties = type.GetProperties()	1✔
212	.Select(x => (x.Name, propertyOpenApiSchema: MapDotnetTypesToOpenApiTypes(x.PropertyType)))	1✔
213	.ToDictionary(x => x.Name, x => x.propertyOpenApiSchema)	2✔
214	};	1✔
215	}
216
217	return null;	×
218	}	7✔
219	}

futurum-dev / dotnet.futurum.webapiendpoint / 1899510545

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