< Summary - Code Coverage

Information
Class: Plainquire.Filter.ValueFilterExpressions.NumericFilterExpression
Assembly: Plainquire.Filter
File(s): /home/runner/work/plainquire/plainquire/Plainquire.Filter/Plainquire.Filter/ValueFilterExpressions/NumericFilterExpression.cs
Tag: 64_13932151703
Line coverage
95%
Covered lines: 47
Uncovered lines: 2
Coverable lines: 49
Total lines: 135
Line coverage: 95.9%
Branch coverage
77%
Covered branches: 17
Total branches: 22
Branch coverage: 77.2%
Method coverage
100%
Covered methods: 8
Total methods: 8
Method coverage: 100%

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.cctor()100%11100%
CanCreateExpressionFor(...)100%11100%
CreateExpressionForValue(...)75%4480%
CreateNumberExpressionByFilterOperator(...)91.66%121291.66%
CreateNumericContainsExpression(...)50%22100%
CreateStringStartsWithExpression(...)50%22100%
CreateStringEndsWithExpression(...)50%22100%

File(s)

/home/runner/work/plainquire/plainquire/Plainquire.Filter/Plainquire.Filter/ValueFilterExpressions/NumericFilterExpression.cs

#LineLine coverage
 1using Plainquire.Filter.Abstractions;
 2using System;
 3using System.Collections.Generic;
 4using System.Diagnostics.CodeAnalysis;
 5using System.Globalization;
 6using System.Linq.Expressions;
 7
 8namespace Plainquire.Filter.ValueFilterExpressions;
 9
 10/// <inheritdoc cref="INumericFilterExpression"/>
 11[SuppressMessage("ReSharper", "MemberCanBePrivate.Global", Justification = "Provided as library, can be used from outsid
 12public class NumericFilterExpression : DefaultFilterExpression, INumericFilterExpression
 13{
 114    private static readonly List<Type> _primitiveNumberTypes = [typeof(byte), typeof(sbyte), typeof(short), typeof(ushor
 15
 16    /// <inheritdoc />
 17    public override ICollection<FilterOperator> SupportedFilterOperators
 18        =>
 494119        [
 494120            FilterOperator.Default,
 494121            FilterOperator.Contains,
 494122            FilterOperator.StartsWith,
 494123            FilterOperator.EndsWith,
 494124            FilterOperator.EqualCaseInsensitive,
 494125            FilterOperator.EqualCaseSensitive,
 494126            FilterOperator.NotEqual,
 494127            FilterOperator.LessThan,
 494128            FilterOperator.LessThanOrEqual,
 494129            FilterOperator.GreaterThan,
 494130            FilterOperator.GreaterThanOrEqual,
 494131            FilterOperator.IsNull,
 494132            FilterOperator.NotNull
 494133        ];
 34
 35    /// <inheritdoc />
 36    public override bool CanCreateExpressionFor(Type type)
 945237        => _primitiveNumberTypes.Contains(type.GetUnderlyingType());
 38
 39    /// <inheritdoc />
 40    protected internal override Expression? CreateExpressionForValue<TEntity, TProperty>(Expression<Func<TEntity, TPrope
 41    {
 431542        if (decimal.TryParse(value, NumberStyles.Any, new CultureInfo(configuration.CultureName), out var decimalValue))
 388343            return CreateNumberExpressionByFilterOperator(propertySelector, filterOperator, decimalValue);
 44
 43245        if (configuration.IgnoreParseExceptions)
 046            return null;
 47
 43248        throw CreateFilterExpressionCreationException("Unable to parse given filter value", propertySelector, filterOper
 49    }
 50
 51    private Expression CreateNumberExpressionByFilterOperator<TEntity, TProperty>(Expression<Func<TEntity, TProperty>> p
 52    {
 388353        var underlyingFilterPropertyType = typeof(TProperty).GetUnderlyingType();
 388354        var typedValue = (TProperty)Convert.ChangeType(value, underlyingFilterPropertyType, CultureInfo.InvariantCulture
 55
 56        switch (filterOperator)
 57        {
 58            case FilterOperator.Default:
 59            case FilterOperator.EqualCaseInsensitive:
 60            case FilterOperator.EqualCaseSensitive:
 105161                return CreateEqualExpression(propertySelector, typedValue);
 62            case FilterOperator.NotEqual:
 28863                return CreateNotEqualExpression(propertySelector, typedValue);
 64            case FilterOperator.Contains:
 38465                return CreateNumericContainsExpression(propertySelector, typedValue);
 66            case FilterOperator.StartsWith:
 72067                return CreateStringStartsWithExpression(propertySelector, typedValue);
 68            case FilterOperator.EndsWith:
 28869                return CreateStringEndsWithExpression(propertySelector, typedValue);
 70            case FilterOperator.LessThan:
 28871                return CreateLessThanExpression(propertySelector, typedValue);
 72            case FilterOperator.LessThanOrEqual:
 28873                return CreateLessThanOrEqualExpression(propertySelector, typedValue);
 74            case FilterOperator.GreaterThan:
 28875                return CreateGreaterThanExpression(propertySelector, typedValue);
 76            case FilterOperator.GreaterThanOrEqual:
 28877                return CreateGreaterThanOrEqualExpression(propertySelector, typedValue);
 78            default:
 079                throw CreateFilterExpressionCreationException($"Filter operator '{filterOperator}' not allowed for prope
 80        }
 81    }
 82
 83    /// <summary>
 84    /// Creates numeric contains expression.
 85    /// </summary>
 86    /// <typeparam name="TEntity">Type of the entity.</typeparam>
 87    /// <typeparam name="TProperty">Type of the property.</typeparam>
 88    /// <param name="propertySelector">The property selector.</param>
 89    /// <param name="value">The value to check for.</param>
 90    /// <returns>
 91    /// The new numeric contains expression.
 92    /// </returns>
 93    public static Expression CreateNumericContainsExpression<TEntity, TProperty>(Expression<Func<TEntity, TProperty>> pr
 94    {
 38495        var valueToUpper = Expression.Constant(value.ToString()?.ToUpper(CultureInfo.InvariantCulture), typeof(string));
 38496        var propertyToString = propertySelector.Body.ObjectToString();
 38497        var propertyToUpper = propertyToString.StringToUpper();
 38498        var propertyContainsValue = propertyToUpper.StringContains(valueToUpper);
 38499        return propertyContainsValue;
 100    }
 101
 102    /// <summary>
 103    /// Creates numeric starts-with expression.
 104    /// </summary>
 105    /// <typeparam name="TEntity">Type of the entity.</typeparam>
 106    /// <typeparam name="TProperty">Type of the property.</typeparam>
 107    /// <param name="propertySelector">The property selector.</param>
 108    /// <param name="value">The value to check for.</param>
 109    /// <returns></returns>
 110    public static Expression CreateStringStartsWithExpression<TEntity, TProperty>(Expression<Func<TEntity, TProperty>> p
 111    {
 720112        var valueToUpper = Expression.Constant(value.ToString()?.ToUpper(CultureInfo.InvariantCulture), typeof(string));
 720113        var propertyToString = propertySelector.Body.ObjectToString();
 720114        var propertyToUpper = propertyToString.StringToUpper();
 720115        var propertyStartsWithValue = propertyToUpper.StringStartsWith(valueToUpper);
 720116        return propertyStartsWithValue;
 117    }
 118
 119    /// <summary>
 120    /// Creates numeric ends-with expression.
 121    /// </summary>
 122    /// <typeparam name="TEntity">Type of the entity.</typeparam>
 123    /// <typeparam name="TProperty">Type of the property.</typeparam>
 124    /// <param name="propertySelector">The property selector.</param>
 125    /// <param name="value">The value to check for.</param>
 126    /// <returns></returns>
 127    public static Expression CreateStringEndsWithExpression<TEntity, TProperty>(Expression<Func<TEntity, TProperty>> pro
 128    {
 288129        var valueToUpper = Expression.Constant(value.ToString()?.ToUpper(CultureInfo.InvariantCulture), typeof(string));
 288130        var propertyToString = propertySelector.Body.ObjectToString();
 288131        var propertyToUpper = propertyToString.StringToUpper();
 288132        var propertyEndsWithValue = propertyToUpper.StringEndsWith(valueToUpper);
 288133        return propertyEndsWithValue;
 134    }
 135}
Generated by: ReportGenerator 5.3.11.0
03/18/2025 - 19:47:37
GitHub | reportgenerator.io

Methods/Properties

.cctor()
SupportedFilterOperators()
CanCreateExpressionFor(System.Type)
CreateExpressionForValue(System.Linq.Expressions.Expression`1<System.Func`2<TEntity,TProperty>>,Plainquire.Filter.Abstractions.FilterOperator,System.String,Plainquire.Filter.Abstractions.FilterConfiguration,Plainquire.Filter.IFilterInterceptor)
CreateNumberExpressionByFilterOperator(System.Linq.Expressions.Expression`1<System.Func`2<TEntity,TProperty>>,Plainquire.Filter.Abstractions.FilterOperator,System.Object)
CreateNumericContainsExpression(System.Linq.Expressions.Expression`1<System.Func`2<TEntity,TProperty>>,System.Object)
CreateStringStartsWithExpression(System.Linq.Expressions.Expression`1<System.Func`2<TEntity,TProperty>>,System.Object)
CreateStringEndsWithExpression(System.Linq.Expressions.Expression`1<System.Func`2<TEntity,TProperty>>,System.Object)