1941142530

Build # 1941142530

Build Type

github

Committed by GitHub

Commit Message

Merge 2a204cca0 into 3cfd70cf6

Pull Request Pull Request #42: System.Text.Json source generator

Run Details

341 of 381 branches covered (89.5%)

Branch coverage included in aggregate %.

33 of 34 new or added lines in 10 files covered. (97.06%)

1 existing line in 1 file now uncovered.

1985 of 2061 relevant lines covered (96.31%)

19915.01 hits per line

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

93.59

/src/Futurum.WebApiEndpoint/Internal/MapFromRequestMultipartMapper.cs

using System.Net;
using System.Reflection;
using System.Text.Json;

using FastMember;

using Futurum.Core.Result;
using Futurum.WebApiEndpoint.Metadata;

using Microsoft.AspNetCore.Http.Extensions;
using Microsoft.AspNetCore.WebUtilities;

namespace Futurum.WebApiEndpoint.Internal;

internal static class MapFromRequestMultipartMapper<TRequestDto>
{
    private static readonly Dictionary<int, Func<TRequestDto, JsonSerializerOptions, MultipartSection, CancellationToken, Task<Result>>> PropertiesToMap = new();

    static MapFromRequestMultipartMapper()
    {
        var typeAccessor = TypeAccessor.Create(typeof(TRequestDto));

        var propertiesWithMapFromMultipartAttribute = WebApiEndpointMetadataTypeService.GetMapFromMultipartProperties(typeof(TRequestDto));

        foreach (var (propertyInfo, mapFromMultipartAttribute) in propertiesWithMapFromMultipartAttribute)
        {
            if (!propertyInfo.CanWrite)
            {
                throw new InvalidOperationException($"Property '{propertyInfo.Name}' on RequestDto type : '{typeof(TRequestDto).FullName}' is readonly");
            }

            PropertiesToMap.Add(mapFromMultipartAttribute.SectionPosition, GetMapper(propertyInfo, typeAccessor, mapFromMultipartAttribute));
        }
    }

    private static Func<TRequestDto, JsonSerializerOptions, MultipartSection, CancellationToken, Task<Result>> GetMapper(PropertyInfo propertyInfo, TypeAccessor typeAccessor,
                                                                                                                         MapFromMultipartAttribute mapFromMultipartAttribute) =>
        mapFromMultipartAttribute.MapFromMultipart switch
        {
            MapFromMultipart.File => GetMapFromFileMapper(propertyInfo, typeAccessor, mapFromMultipartAttribute),
            MapFromMultipart.Json => GetMapFromJsonMapper(propertyInfo, typeAccessor, mapFromMultipartAttribute),
            _                     => (_, _, _, _) => Result.FailAsync($"Failed to MapFrom property : '{propertyInfo.Name}' using MapFrom : '{mapFromMultipartAttribute}'")
        };

    private static Func<TRequestDto, JsonSerializerOptions, MultipartSection, CancellationToken, Task<Result>> GetMapFromFileMapper(PropertyInfo propertyInfo, TypeAccessor typeAccessor,
                                                                                                                                    MapFromMultipartAttribute mapFromMultipartAttribute)
    {
        Result Map(MultipartSection multipartSection, TRequestDto requestDto, CancellationToken cancellationToken)
        {
            if (multipartSection.GetContentDispositionHeader() != null)
            {
                var fileSection = multipartSection.AsFileSection();

                if (fileSection != null)
                {
                    // Don't trust the file name sent by the client. To display the file name, HTML-encode the value.
                    var trustedFileNameForDisplay = WebUtility.HtmlEncode(fileSection.FileName);

                    typeAccessor[requestDto, propertyInfo.Name] = new FormFile(fileSection.FileStream, 0, fileSection.FileStream.Length, fileSection.Name, trustedFileNameForDisplay);

                    return Result.Ok();
                }
            }

            return Result.Fail($"MultipartSection not set to File");
        }

        Result Execute(MultipartSection multipartSection, TRequestDto dto, CancellationToken cancellationToken)
        {
            return Map(multipartSection, dto, cancellationToken);
        }

        return (requestDto, _, multipartSection, cancellationToken) => Result.Try(() => Execute(multipartSection, requestDto, cancellationToken),
                                                                               () => $"Failed to Files MapMultipart for SectionPosition : '{mapFromMultipartAttribute.SectionPosition}'")
                                                                          .ToResultAsync();
    }

    private static Func<TRequestDto, JsonSerializerOptions, MultipartSection, CancellationToken, Task<Result>> GetMapFromJsonMapper(PropertyInfo propertyInfo, TypeAccessor typeAccessor,
                                                                                                                                    MapFromMultipartAttribute mapFromMultipartAttribute)
    {
        async Task MapAsync(MultipartSection multipartSection, TRequestDto requestDto, JsonSerializerOptions jsonSerializerOptions, CancellationToken cancellationToken)
        {
            multipartSection.Body.Seek(0, SeekOrigin.Begin);
            var value = await JsonSerializer.DeserializeAsync(multipartSection.Body, propertyInfo.PropertyType, jsonSerializerOptions, cancellationToken);
            typeAccessor[requestDto, propertyInfo.Name] = value;
        }

        Task Execute(MultipartSection multipartSection, TRequestDto dto, JsonSerializerOptions jsonSerializerOptions, CancellationToken cancellationToken)
        {
            return MapAsync(multipartSection, dto, jsonSerializerOptions, cancellationToken);
        }

        return (requestDto, jsonSerializerOptions, multipartSection, cancellationToken) => Result.TryAsync(() => Execute(multipartSection, requestDto, jsonSerializerOptions, cancellationToken),
                                                                                                           () => $"Failed to Json MapMultipart for SectionPosition : '{mapFromMultipartAttribute.SectionPosition}'");
    }

    private static Task<Result> MapMultipartAsync(HttpContext httpContext, JsonSerializerOptions jsonSerializerOptions, TRequestDto dto, CancellationToken cancellationToken)
    {
        async Task<Result> Execute()
        {
            var results = new List<Result>();

            var boundary = httpContext.Request.GetMultipartBoundary();

            var reader = new MultipartReader(boundary, httpContext.Request.Body);

            var sectionCount = 0;
            var section = await reader.ReadNextSectionAsync(cancellationToken);
            while (section != null)
            {
                if (PropertiesToMap.TryGetValue(sectionCount, out var mapper))
                {
                    var result = await mapper(dto, jsonSerializerOptions, section, cancellationToken);

                    results.Add(result);
                }

                section = await reader.ReadNextSectionAsync(cancellationToken);
                sectionCount++;
            }

            return results.Combine();
        }

        return Result.TryAsync(Execute, () => $"Failed to MapMultipart");
    }

    public static Task<Result> MapAsync(HttpContext httpContext, JsonSerializerOptions jsonSerializerOptions, TRequestDto dto, CancellationToken cancellationToken) =>
        PropertiesToMap.Count switch
        {
            0 => Result.OkAsync(),
            _ => MapMultipartAsync(httpContext, jsonSerializerOptions, dto, cancellationToken)
        };
}

1	using System.Net;
2	using System.Reflection;
3	using System.Text.Json;
4
5	using FastMember;
6
7	using Futurum.Core.Result;
8	using Futurum.WebApiEndpoint.Metadata;
9
10	using Microsoft.AspNetCore.Http.Extensions;
11	using Microsoft.AspNetCore.WebUtilities;
12
13	namespace Futurum.WebApiEndpoint.Internal;
14
15	internal static class MapFromRequestMultipartMapper<TRequestDto>
16	{
17	private static readonly Dictionary<int, Func<TRequestDto, JsonSerializerOptions, MultipartSection, CancellationToken, Task<Result>>> PropertiesToMap = new();	3✔
18
19	static MapFromRequestMultipartMapper()
20	{	3✔
21	var typeAccessor = TypeAccessor.Create(typeof(TRequestDto));	3✔
22
23	var propertiesWithMapFromMultipartAttribute = WebApiEndpointMetadataTypeService.GetMapFromMultipartProperties(typeof(TRequestDto));	3✔
24
25	foreach (var (propertyInfo, mapFromMultipartAttribute) in propertiesWithMapFromMultipartAttribute)	18✔
26	{	5✔
27	if (!propertyInfo.CanWrite)	5✔
28	{	1✔
29	throw new InvalidOperationException($"Property '{propertyInfo.Name}' on RequestDto type : '{typeof(TRequestDto).FullName}' is readonly");	1✔
30	}
31
32	PropertiesToMap.Add(mapFromMultipartAttribute.SectionPosition, GetMapper(propertyInfo, typeAccessor, mapFromMultipartAttribute));	4✔
33	}	4✔
34	}	2✔
35
36	private static Func<TRequestDto, JsonSerializerOptions, MultipartSection, CancellationToken, Task<Result>> GetMapper(PropertyInfo propertyInfo, TypeAccessor typeAccessor,
37	MapFromMultipartAttribute mapFromMultipartAttribute) =>
38	mapFromMultipartAttribute.MapFromMultipart switch	4!
39	{	4✔
40	MapFromMultipart.File => GetMapFromFileMapper(propertyInfo, typeAccessor, mapFromMultipartAttribute),	2✔
41	MapFromMultipart.Json => GetMapFromJsonMapper(propertyInfo, typeAccessor, mapFromMultipartAttribute),	2✔
NEW 42	_ => (_, _, _, _) => Result.FailAsync($"Failed to MapFrom property : '{propertyInfo.Name}' using MapFrom : '{mapFromMultipartAttribute}'")	×
43	};	4✔
44
45	private static Func<TRequestDto, JsonSerializerOptions, MultipartSection, CancellationToken, Task<Result>> GetMapFromFileMapper(PropertyInfo propertyInfo, TypeAccessor typeAccessor,
46	MapFromMultipartAttribute mapFromMultipartAttribute)
47	{	2✔
48	Result Map(MultipartSection multipartSection, TRequestDto requestDto, CancellationToken cancellationToken)
49	{
50	if (multipartSection.GetContentDispositionHeader() != null)
51	{
52	var fileSection = multipartSection.AsFileSection();
53
54	if (fileSection != null)
55	{
56	// Don't trust the file name sent by the client. To display the file name, HTML-encode the value.
57	var trustedFileNameForDisplay = WebUtility.HtmlEncode(fileSection.FileName);
58
59	typeAccessor[requestDto, propertyInfo.Name] = new FormFile(fileSection.FileStream, 0, fileSection.FileStream.Length, fileSection.Name, trustedFileNameForDisplay);
60
61	return Result.Ok();
62	}
63	}
64
65	return Result.Fail($"MultipartSection not set to File");
66	}
67
68	Result Execute(MultipartSection multipartSection, TRequestDto dto, CancellationToken cancellationToken)
69	{
70	return Map(multipartSection, dto, cancellationToken);
71	}
72
73	return (requestDto, _, multipartSection, cancellationToken) => Result.Try(() => Execute(multipartSection, requestDto, cancellationToken),	6✔
74	() => $"Failed to Files MapMultipart for SectionPosition : '{mapFromMultipartAttribute.SectionPosition}'")	×
75	.ToResultAsync();	4✔
76	}	2✔
77
78	private static Func<TRequestDto, JsonSerializerOptions, MultipartSection, CancellationToken, Task<Result>> GetMapFromJsonMapper(PropertyInfo propertyInfo, TypeAccessor typeAccessor,
79	MapFromMultipartAttribute mapFromMultipartAttribute)
80	{	2✔
81	async Task MapAsync(MultipartSection multipartSection, TRequestDto requestDto, JsonSerializerOptions jsonSerializerOptions, CancellationToken cancellationToken)
82	{	2✔
83	multipartSection.Body.Seek(0, SeekOrigin.Begin);	2✔
84	var value = await JsonSerializer.DeserializeAsync(multipartSection.Body, propertyInfo.PropertyType, jsonSerializerOptions, cancellationToken);	2✔
85	typeAccessor[requestDto, propertyInfo.Name] = value;	2✔
86	}	2✔
87
88	Task Execute(MultipartSection multipartSection, TRequestDto dto, JsonSerializerOptions jsonSerializerOptions, CancellationToken cancellationToken)
89	{
90	return MapAsync(multipartSection, dto, jsonSerializerOptions, cancellationToken);
91	}
92
93	return (requestDto, jsonSerializerOptions, multipartSection, cancellationToken) => Result.TryAsync(() => Execute(multipartSection, requestDto, jsonSerializerOptions, cancellationToken),	6✔
94	() => $"Failed to Json MapMultipart for SectionPosition : '{mapFromMultipartAttribute.SectionPosition}'");	4✔
95	}	2✔
96
97	private static Task<Result> MapMultipartAsync(HttpContext httpContext, JsonSerializerOptions jsonSerializerOptions, TRequestDto dto, CancellationToken cancellationToken)
98	{	2✔
99	async Task<Result> Execute()
100	{	2✔
101	var results = new List<Result>();	2✔
102
103	var boundary = httpContext.Request.GetMultipartBoundary();	2✔
104
105	var reader = new MultipartReader(boundary, httpContext.Request.Body);	2✔
106
107	var sectionCount = 0;	2✔
108	var section = await reader.ReadNextSectionAsync(cancellationToken);	2✔
109	while (section != null)	6✔
110	{	4✔
111	if (PropertiesToMap.TryGetValue(sectionCount, out var mapper))	4✔
112	{	4✔
113	var result = await mapper(dto, jsonSerializerOptions, section, cancellationToken);	4✔
114
115	results.Add(result);	4✔
116	}	4✔
117
118	section = await reader.ReadNextSectionAsync(cancellationToken);	4✔
119	sectionCount++;	4✔
120	}	4✔
121
122	return results.Combine();	2✔
123	}	2✔
124
125	return Result.TryAsync(Execute, () => $"Failed to MapMultipart");	2✔
126	}	2✔
127
128	public static Task<Result> MapAsync(HttpContext httpContext, JsonSerializerOptions jsonSerializerOptions, TRequestDto dto, CancellationToken cancellationToken) =>
129	PropertiesToMap.Count switch	2!
130	{	2✔
UNCOV 131	0 => Result.OkAsync(),	×
132	_ => MapMultipartAsync(httpContext, jsonSerializerOptions, dto, cancellationToken)	2✔
133	};	2✔
134	}

futurum-dev / dotnet.futurum.webapiendpoint / 1941142530

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