< Summary

Information
Class: Services.FiltersServices.DataFilter<T>
Assembly: Services
File(s): /home/runner/work/Studio2Prod/Studio2Prod/AppRepository/FiltersServices/DataFilter.cs
Line coverage
100%
Covered lines: 67
Uncovered lines: 0
Coverable lines: 67
Total lines: 212
Line coverage: 100%
Branch coverage
93%
Covered branches: 56
Total branches: 60
Branch coverage: 93.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
FilterByInt(...)100%22100%
FilterByDate(...)100%44100%
FilterByString(...)100%88100%
FilterByDecimal(...)100%44100%
FilterByDouble(...)100%44100%
FilterByPeriod(...)77.77%1818100%
FilterByEnum(...)100%44100%
FilterByTimeSpan(...)100%44100%
FilterByStringList(...)100%1212100%

File(s)

/home/runner/work/Studio2Prod/Studio2Prod/AppRepository/FiltersServices/DataFilter.cs

#LineLine coverage
 1namespace Services.FiltersServices
 2{
 3    public class DataFilter<T> : IDataFilter<T>
 4    {
 5        public IEnumerable<T> FilterByInt(
 6            IEnumerable<T> data,
 7            Func<T, int> propertySelector,
 8            int? filterValue)
 9        {
 3110            if (filterValue != null)
 7611                return data.Where(item => propertySelector(item) == filterValue);
 12            else
 13            {
 114                return data;
 15            }
 16        }
 17
 18        public IEnumerable<T> FilterByDate(
 19        IEnumerable<T> data,
 20        Func<T, DateTime?> propertySelector,
 21        DateTime? filterDate)
 22        {
 423            if (filterDate != null)
 24            {
 325                DateTime filterDateDay = filterDate.Value.Date;
 1126                return data.Where(item => propertySelector(item)?.Date == filterDateDay);
 27            }
 28            else
 29            {
 130                return data;
 31            }
 32        }
 33
 34
 35        public IEnumerable<T> FilterByString(
 36            IEnumerable<T> data,
 37            Func<T, string?> propertySelector,
 38            string? filterValue,
 39            bool exactMatch = false)
 40        {
 82141            if (!string.IsNullOrEmpty(filterValue))
 42            {
 30043                if (exactMatch)
 44                {
 545                    return data.Where(item => propertySelector(item) != null &&
 546                                              string.Equals(propertySelector(item), filterValue, StringComparison.Ordina
 47                }
 48                else
 49                {
 29950                    return data.Where(item =>
 29951                    {
 173052                        var value = propertySelector(item);
 173053                        return value != null &&
 173054                               value.IndexOf(filterValue, StringComparison.OrdinalIgnoreCase) >= 0;
 29955                    });
 56                }
 57            }
 58            else
 59            {
 52160                return data;
 61            }
 62        }
 63
 64
 65
 66        public IEnumerable<T> FilterByDecimal(
 67         IEnumerable<T> data,
 68         Func<T, decimal?> propertySelector,
 69         decimal? filterValue,
 70         decimal tolerance = 1)
 71        {
 9072            if (filterValue != null)
 73            {
 7174                return data.Where(item => propertySelector(item) is decimal d && Math.Abs(d - filterValue.Value) <= tole
 75            }
 76            else
 77            {
 7678                return data;
 79            }
 80        }
 81
 82
 83        public IEnumerable<T> FilterByDouble(
 84            IEnumerable<T> data,
 85            Func<T, double?> propertySelector,
 86            double? filterValue,
 87            double tolerance = 1)
 88        {
 9189            if (filterValue != null)
 90            {
 9091                return data.Where(item => propertySelector(item) is double d && Math.Abs(d - filterValue.Value) <= toler
 92            }
 93            else
 94            {
 7495                return data;
 96            }
 97        }
 98
 99
 100
 101        public IEnumerable<T> FilterByPeriod(
 102            IEnumerable<T> data,
 103            Func<T, DateTime> propertySelector,
 104            DateTime? startDate,
 105            DateTime? endDate)
 106        {
 4107            if (startDate != null && endDate != null)
 108            {
 6109                return data.Where(item => propertySelector(item) >= startDate && propertySelector(item) <= endDate);
 110            }
 3111            else if (startDate != null)
 112            {
 4113                return data.Where(item => propertySelector(item) >= startDate);
 114            }
 2115            else if (endDate != null)
 116            {
 4117                return data.Where(item => propertySelector(item) <= endDate);
 118            }
 119            else
 120            {
 1121                return data;
 122            }
 123        }
 124
 125        public IEnumerable<TItem> FilterByEnum<TItem, TEnum>(
 126            IEnumerable<TItem> data,
 127            Func<TItem, TEnum?> propertySelector,
 128            TEnum? filterValue)
 129            where TEnum : struct, Enum
 130        {
 122131            if (filterValue != null)
 132            {
 17133                return data.Where(item =>
 65134                    propertySelector(item) != null &&
 65135                    propertySelector(item).Equals(filterValue));
 136            }
 137            else
 138            {
 105139                return data;
 140            }
 141        }
 142
 143        public IEnumerable<T> FilterByTimeSpan(
 144            IEnumerable<T> data,
 145            Func<T, TimeSpan?> propertySelector,
 146            TimeSpan? filterTimeSpan)
 147        {
 2148            if (filterTimeSpan != null)
 149            {
 1150                return data.Where(item =>
 7151                    propertySelector(item) is TimeSpan ts &&
 7152                    Math.Abs(ts.TotalSeconds - filterTimeSpan.Value.TotalSeconds) <= 1);
 153            }
 154            else
 155            {
 1156                return data;
 157            }
 158        }
 159
 160        /// <summary>
 161        /// Фильтрует данные по списку строк с использованием логики OR (элемент должен соответствовать хотя бы одному з
 162        /// </summary>
 163        /// <param name="data">Исходные данные для фильтрации</param>
 164        /// <param name="propertySelector">Селектор свойства для фильтрации</param>
 165        /// <param name="filterValues">Список значений для фильтрации</param>
 166        /// <param name="exactMatch">Если true - точное совпадение, если false - частичное (Contains)</param>
 167        /// <returns>Отфильтрованные данные</returns>
 168        public IEnumerable<T> FilterByStringList(
 169            IEnumerable<T> data,
 170            Func<T, string?> propertySelector,
 171            IEnumerable<string> filterValues,
 172            bool exactMatch = false)
 173        {
 174            // Если список пустой или null - возвращаем данные без фильтрации
 6175            if (filterValues == null || !filterValues.Any())
 176            {
 2177                return data;
 178            }
 179
 180            // Убираем пустые и null значения из списка
 14181            var nonEmptyValues = filterValues.Where(v => !string.IsNullOrEmpty(v)).ToList();
 182
 4183            if (!nonEmptyValues.Any())
 184            {
 1185                return data;
 186            }
 187
 3188            return data.Where(item =>
 3189            {
 9190                var propertyValue = propertySelector(item);
 9191                if (propertyValue == null)
 3192                {
 2193                    return false;
 3194                }
 3195
 7196                if (exactMatch)
 3197                {
 3198                    // Точное совпадение (case-insensitive)
 3199                    return nonEmptyValues.Any(filterValue =>
 8200                        string.Equals(propertyValue, filterValue, StringComparison.OrdinalIgnoreCase));
 3201                }
 3202                else
 3203                {
 3204                    // Частичное совпадение (Contains, case-insensitive)
 4205                    return nonEmptyValues.Any(filterValue =>
 11206                        propertyValue.IndexOf(filterValue, StringComparison.OrdinalIgnoreCase) >= 0);
 3207                }
 3208            });
 209        }
 210    }
 211}
 212
Generated by: ReportGenerator 5.5.11.0
10/25/2026 - 07:43:48
GitHub | reportgenerator.io

Methods/Properties

FilterByInt(System.Collections.Generic.IEnumerable`1<T>,System.Func`2<T,System.Int32>,System.Nullable`1<System.Int32>)
FilterByDate(System.Collections.Generic.IEnumerable`1<T>,System.Func`2<T,System.Nullable`1<System.DateTime>>,System.Nullable`1<System.DateTime>)
FilterByString(System.Collections.Generic.IEnumerable`1<T>,System.Func`2<T,System.String>,System.String,System.Boolean)
FilterByDecimal(System.Collections.Generic.IEnumerable`1<T>,System.Func`2<T,System.Nullable`1<System.Decimal>>,System.Nullable`1<System.Decimal>,System.Decimal)
FilterByDouble(System.Collections.Generic.IEnumerable`1<T>,System.Func`2<T,System.Nullable`1<System.Double>>,System.Nullable`1<System.Double>,System.Double)
FilterByPeriod(System.Collections.Generic.IEnumerable`1<T>,System.Func`2<T,System.DateTime>,System.Nullable`1<System.DateTime>,System.Nullable`1<System.DateTime>)
FilterByEnum(System.Collections.Generic.IEnumerable`1<TItem>,System.Func`2<TItem,System.Nullable`1<TEnum>>,System.Nullable`1<TEnum>)
FilterByTimeSpan(System.Collections.Generic.IEnumerable`1<T>,System.Func`2<T,System.Nullable`1<System.TimeSpan>>,System.Nullable`1<System.TimeSpan>)
FilterByStringList(System.Collections.Generic.IEnumerable`1<T>,System.Func`2<T,System.String>,System.Collections.Generic.IEnumerable`1<System.String>,System.Boolean)