5805868292

pending completion

Build # 5805868292

Build Type

push

github

Committed by

lucaslorentz

Commit Message

Search by completed time

Run Details

12 of 12 new or added lines in 5 files covered. (100.0%)

2311 of 2794 relevant lines covered (82.71%)

145.34 hits per line

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

70.21

/src/LLL.DurableTask.Api/Extensions/HttpContextExtensions.cs

﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;

namespace LLL.DurableTask.Api.Extensions
{
    static class HttpContextExtensions
    {
        private static JsonSerializerSettings _serializerSettings = new JsonSerializerSettings
        {
            DateTimeZoneHandling = DateTimeZoneHandling.Utc,
            ContractResolver = new DefaultContractResolver
            {
                NamingStrategy = new CamelCaseNamingStrategy()
            },
            Converters = { new StringEnumConverter() }
        };

        public static T ParseQuery<T>(this HttpContext context)
            where T : new()
        {
            var obj = new T();
            foreach (var property in typeof(T).GetProperties())
            {
                if (context.Request.Query.TryGetValue(property.Name, out var values))
                {
                    if (property.PropertyType.IsGenericType && (
                        property.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>)
                        || property.PropertyType.GetGenericTypeDefinition() == typeof(ICollection<>)))
                    {
                        var elementType = property.PropertyType.GenericTypeArguments[0];
                        var array = Array.CreateInstance(elementType, values.Count);
                        for (var i = 0; i < values.Count; i++)
                        {
                            var convertedValue = ConvertQueryValue(elementType, values[i]);
                            array.SetValue(convertedValue, i);
                        }
                        SetProperty(property, obj, array);
                    }
                    else
                    {
                        var firstValue = values.First();
                        var convertedValue = ConvertQueryValue(property.PropertyType, firstValue);
                        SetProperty(property, obj, convertedValue);
                    }
                }
            }
            return obj;
        }

        static void SetProperty(PropertyInfo property, object target, object value)
        {
            if (property.CanWrite)
            {
                property.SetValue(target, value);
                return;
            }

            var propertyValue = property.GetValue(target);
            if (propertyValue is IDictionary targetDict && value is IDictionary dictValue)
            {
                foreach (var key in dictValue.Keys)
                    targetDict.Add(key, dictValue[key]);
                return; 
            }

            throw new Exception($"Property {property.Name} cannot be written");
        }

        static object ConvertQueryValue(Type type, string value)
        {
            type = Nullable.GetUnderlyingType(type) ?? type;

            if (type.IsEnum)
            {
                return Enum.Parse(type, value);
            }
            else
            {
                var typeCode = Type.GetTypeCode(type);
                switch (typeCode)
                {
                    case TypeCode.Object:
                        return JsonConvert.DeserializeObject(value, type);
                    default:
                        return Convert.ChangeType(value, type);
                }

            }
        }

        public static async Task<T> ParseBody<T>(this HttpContext context)
        {
            using var reader = new StreamReader(context.Request.Body, Encoding.UTF8);
            var json = await reader.ReadToEndAsync();
            return JsonConvert.DeserializeObject<T>(json, _serializerSettings);
        }

        public static async Task RespondJson(
            this HttpContext context,
            object data,
            int statusCode = 200)
        {
            var json = JsonConvert.SerializeObject(data, _serializerSettings);
            context.Response.StatusCode = statusCode;
            context.Response.ContentType = "application/json; charset=utf-8";
            await context.Response.WriteAsync(json);
        }
    }
}

1	using System;
2	using System.Collections;
3	using System.Collections.Generic;
4	using System.IO;
5	using System.Linq;
6	using System.Reflection;
7	using System.Text;
8	using System.Threading.Tasks;
9	using Microsoft.AspNetCore.Http;
10	using Newtonsoft.Json;
11	using Newtonsoft.Json.Converters;
12	using Newtonsoft.Json.Serialization;
13
14	namespace LLL.DurableTask.Api.Extensions
15	{
16	static class HttpContextExtensions
17	{
18	private static JsonSerializerSettings _serializerSettings = new JsonSerializerSettings	1✔
19	{	1✔
20	DateTimeZoneHandling = DateTimeZoneHandling.Utc,	1✔
21	ContractResolver = new DefaultContractResolver	1✔
22	{	1✔
23	NamingStrategy = new CamelCaseNamingStrategy()	1✔
24	},	1✔
25	Converters = { new StringEnumConverter() }	1✔
26	};	1✔
27
28	public static T ParseQuery<T>(this HttpContext context)
29	where T : new()
30	{
31	var obj = new T();	2✔
32	foreach (var property in typeof(T).GetProperties())	56✔
33	{
34	if (context.Request.Query.TryGetValue(property.Name, out var values))	26✔
35	{
36	if (property.PropertyType.IsGenericType && (	3✔
37	property.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>)	3✔
38	\|\| property.PropertyType.GetGenericTypeDefinition() == typeof(ICollection<>)))	3✔
39	{
40	var elementType = property.PropertyType.GenericTypeArguments[0];	×
41	var array = Array.CreateInstance(elementType, values.Count);	×
42	for (var i = 0; i < values.Count; i++)	×
43	{
44	var convertedValue = ConvertQueryValue(elementType, values[i]);	×
45	array.SetValue(convertedValue, i);	×
46	}
47	SetProperty(property, obj, array);	×
48	}
49	else
50	{
51	var firstValue = values.First();	3✔
52	var convertedValue = ConvertQueryValue(property.PropertyType, firstValue);	3✔
53	SetProperty(property, obj, convertedValue);	3✔
54	}
55	}
56	}
57	return obj;	2✔
58	}
59
60	static void SetProperty(PropertyInfo property, object target, object value)
61	{
62	if (property.CanWrite)	3✔
63	{
64	property.SetValue(target, value);	3✔
65	return;	3✔
66	}
67
68	var propertyValue = property.GetValue(target);	×
69	if (propertyValue is IDictionary targetDict && value is IDictionary dictValue)	×
70	{
71	foreach (var key in dictValue.Keys)	×
72	targetDict.Add(key, dictValue[key]);	×
73	return;	×
74	}
75
76	throw new Exception($"Property {property.Name} cannot be written");	×
77	}
78
79	static object ConvertQueryValue(Type type, string value)
80	{
81	type = Nullable.GetUnderlyingType(type) ?? type;	3✔
82
83	if (type.IsEnum)	3✔
84	{
85	return Enum.Parse(type, value);	×
86	}
87	else
88	{
89	var typeCode = Type.GetTypeCode(type);	3✔
90	switch (typeCode)
91	{
92	case TypeCode.Object:
93	return JsonConvert.DeserializeObject(value, type);	×
94	default:
95	return Convert.ChangeType(value, type);	3✔
96	}
97
98	}
99	}
100
101	public static async Task<T> ParseBody<T>(this HttpContext context)
102	{
103	using var reader = new StreamReader(context.Request.Body, Encoding.UTF8);	5✔
104	var json = await reader.ReadToEndAsync();	5✔
105	return JsonConvert.DeserializeObject<T>(json, _serializerSettings);	5✔
106	}
107
108	public static async Task RespondJson(
109	this HttpContext context,
110	object data,
111	int statusCode = 200)
112	{
113	var json = JsonConvert.SerializeObject(data, _serializerSettings);	11✔
114	context.Response.StatusCode = statusCode;	11✔
115	context.Response.ContentType = "application/json; charset=utf-8";	11✔
116	await context.Response.WriteAsync(json);	11✔
117	}
118	}
119	}

lucaslorentz / durabletask-extensions / 5805868292

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