< Summary - Code Coverage

Information
Class: Plainquire.Filter.JsonConverters.EntityFilterConverter<T>
Assembly: Plainquire.Filter
File(s): /home/runner/work/plainquire/plainquire/Plainquire.Filter/Plainquire.Filter/JsonConverters/EntityFilterConverter.cs
Tag: 64_13932151703
Line coverage
100%
Covered lines: 2
Uncovered lines: 0
Coverable lines: 2
Total lines: 115
Line coverage: 100%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage
100%
Covered methods: 2
Total methods: 2
Method coverage: 100%

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
Read(...)100%11100%
Write(...)100%11100%

File(s)

/home/runner/work/plainquire/plainquire/Plainquire.Filter/Plainquire.Filter/JsonConverters/EntityFilterConverter.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Linq;
 4using System.Text.Json;
 5using System.Text.Json.Serialization;
 6
 7namespace Plainquire.Filter.JsonConverters;
 8
 9/// <summary>
 10/// <see cref="EntityFilter{TEntity}"/> specific JSON converter for Microsoft (System.Text.Json) JSON.
 11/// Implements <see cref="JsonConverter{T}" />
 12/// </summary>
 13/// <typeparam name="TEntity">The type of the entity to filter for.</typeparam>
 14/// <seealso cref="JsonConverter{T}" />
 15public class EntityFilterConverter<TEntity> : JsonConverter<EntityFilter<TEntity>>
 16{
 17    /// <inheritdoc />
 18    public override EntityFilter<TEntity> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions opti
 336819        => EntityFilterConverter.Read<EntityFilter<TEntity>>(ref reader, options);
 20
 21    /// <inheritdoc />
 22    public override void Write(Utf8JsonWriter writer, EntityFilter<TEntity> value, JsonSerializerOptions options)
 336123        => EntityFilterConverter.Write(writer, value, options);
 24}
 25
 26/// <summary>
 27/// <see cref="EntityFilter"/> specific JSON converter for Microsoft (System.Text.Json) JSON.
 28/// Implements <see cref="JsonConverter{T}" />
 29/// </summary>
 30/// <seealso cref="JsonConverter{T}" />
 31public class EntityFilterConverter : JsonConverter<EntityFilter>
 32{
 33    /// <inheritdoc />
 34    public override EntityFilter Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 35        => Read<EntityFilter>(ref reader, options);
 36
 37    /// <inheritdoc />
 38    public override void Write(Utf8JsonWriter writer, EntityFilter value, JsonSerializerOptions options)
 39        => Write(writer, value, options);
 40
 41    internal static TEntityFilter Read<TEntityFilter>(ref Utf8JsonReader reader, JsonSerializerOptions options)
 42        where TEntityFilter : EntityFilter, new()
 43    {
 44        var entityFilterData = JsonSerializer.Deserialize<EntityFilterConverterData>(ref reader, options) ?? new EntityF
 45        var propertyFilters = GetPropertyFilters(entityFilterData);
 46
 47        return new TEntityFilter
 48        {
 49            PropertyFilters = propertyFilters ?? [],
 50            NestedFilters = entityFilterData.NestedFilters ?? [],
 51            Configuration = entityFilterData.Configuration
 52        };
 53    }
 54
 55    internal static void Write<TEntityFilter>(Utf8JsonWriter writer, TEntityFilter value, JsonSerializerOptions options)
 56        where TEntityFilter : EntityFilter
 57    {
 58        var propertyFiltersData = GetPropertyFilterData(value);
 59
 60        var entityFilterData = new EntityFilterConverterData
 61        {
 62            PropertyFilters = propertyFiltersData,
 63            NestedFilters = value.NestedFilters,
 64            Configuration = value.Configuration
 65        };
 66
 67        JsonSerializer.Serialize(writer, entityFilterData, options);
 68    }
 69
 70    internal static List<PropertyFilter>? GetPropertyFilters(EntityFilterConverterData entityFilterData)
 71        => entityFilterData
 72            .PropertyFilters?
 73            .Select(filter => new PropertyFilter(
 74                propertyName: filter.PropertyName,
 75                valueFilters: filter.ValueFilters
 76                    .Select(valueFilter => ValueFilter.Create(
 77                        valueFilter.Operator,
 78                        valueFilter.Value,
 79                        entityFilterData.Configuration
 80                    ))
 81                    .ToArray()
 82            ))
 83            .ToList();
 84
 85    internal static List<PropertyFilterConverterData> GetPropertyFilterData<TEntityFilter>(TEntityFilter entityFilter) w
 86        => entityFilter.PropertyFilters
 87            .Select(filter => new PropertyFilterConverterData
 88            (
 89                propertyName: filter.PropertyName,
 90                valueFilters: filter.ValueFilters
 91                    .Select(valueFilter => new ValueFilterConverterData { Operator = valueFilter.Operator, Value = value
 92                    .ToList()
 93            ))
 94            .ToList();
 95
 96    /// <summary>
 97    /// <see cref="EntityFilter{TEntity}"/> specific JSON converter factory for Microsoft (System.Text.Json) JSON.
 98    /// Implements <see cref="JsonConverterFactory" />
 99    /// </summary>
 100    /// <seealso cref="JsonConverterFactory" />
 101    public class Factory : JsonConverterFactory
 102    {
 103        /// <inheritdoc />
 104        public override bool CanConvert(Type typeToConvert)
 105            => typeToConvert.IsGenericEntityFilter();
 106
 107        /// <inheritdoc />
 108        public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
 109        {
 110            var entityType = typeToConvert.GetGenericArguments()[0];
 111            var entityFilterConverterType = typeof(EntityFilterConverter<>).MakeGenericType(entityType);
 112            return (JsonConverter?)Activator.CreateInstance(entityFilterConverterType);
 113        }
 114    }
 115}