Fix: Rename Generic.CL folder to flat structure, update csproj and references
This commit is contained in:
@@ -0,0 +1,286 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
|
||||
namespace Generic.Services;
|
||||
|
||||
public static class AdvancedFilterExtension
|
||||
{
|
||||
public static IQueryable<T> ApplyAdvancedFilter<T, TFilter>(this IQueryable<T> query, TFilter filter)
|
||||
where TFilter : class
|
||||
{
|
||||
if (filter == null) return query;
|
||||
|
||||
var entityType = typeof(T);
|
||||
var filterProperties = typeof(TFilter).GetProperties()
|
||||
.Where(p => p.GetValue(filter) != null)
|
||||
.ToDictionary(p => p.Name, p => p.GetValue(filter));
|
||||
|
||||
if (!filterProperties.Any()) return query;
|
||||
|
||||
// 1. Map Entity Properties with their Paths and Levels
|
||||
var entityMap = ScanEntity(entityType);
|
||||
|
||||
// 2. Process by Level (Priority)
|
||||
var maxLevel = entityMap.Any() ? entityMap.Max(m => m.Level) : 0;
|
||||
|
||||
var parameter = Expression.Parameter(entityType, "x");
|
||||
|
||||
// We keep track of which filter properties we've already applied
|
||||
var appliedFilterKeys = new HashSet<string>();
|
||||
|
||||
for (int level = 1; level <= maxLevel; level++)
|
||||
{
|
||||
var levelProperties = entityMap.Where(m => m.Level == level).ToList();
|
||||
|
||||
foreach (var meta in levelProperties)
|
||||
{
|
||||
// If this property name exists in our filter and hasn't been applied yet
|
||||
if (filterProperties.TryGetValue(meta.Name, out var filterValue) && !appliedFilterKeys.Contains(meta.Name))
|
||||
{
|
||||
// If it's a root property (Level 1)
|
||||
if (meta.Level == 1)
|
||||
{
|
||||
var comparison = BuildComparison(parameter, meta.PropertyInfo, filterValue);
|
||||
if (comparison != null)
|
||||
{
|
||||
var lambda = Expression.Lambda<Func<T, bool>>(comparison, parameter);
|
||||
query = query.Where(lambda);
|
||||
appliedFilterKeys.Add(meta.Name);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// It's a nested property. We need to find the "Branch Root" (the first collection in the path)
|
||||
var branchInfo = FindBranchRoot(meta);
|
||||
if (branchInfo != null)
|
||||
{
|
||||
// Discover all other filter properties that belong to this same branch
|
||||
var branchFilters = DiscoverBranchFilters(branchInfo, entityMap, filterProperties, appliedFilterKeys);
|
||||
|
||||
// Apply them all together in one .Any() or nested .Where()
|
||||
query = ApplyBranchFilter(query, parameter, branchInfo, branchFilters);
|
||||
|
||||
foreach (var usedKey in branchFilters.Keys) appliedFilterKeys.Add(usedKey);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return query;
|
||||
}
|
||||
|
||||
private static List<PropertyMetadata> ScanEntity(Type type, int level = 1, string path = "", PropertyMetadata parent = null)
|
||||
{
|
||||
var metaList = new List<PropertyMetadata>();
|
||||
var props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
|
||||
|
||||
foreach (var p in props)
|
||||
{
|
||||
var currentPath = string.IsNullOrEmpty(path) ? p.Name : $"{path}.{p.Name}";
|
||||
var meta = new PropertyMetadata
|
||||
{
|
||||
Name = p.Name,
|
||||
Path = currentPath,
|
||||
Level = level,
|
||||
PropertyInfo = p,
|
||||
PropertyType = p.PropertyType,
|
||||
Parent = parent
|
||||
};
|
||||
|
||||
metaList.Add(meta);
|
||||
|
||||
// If it's a complex type (not a system type or enum), dive deeper
|
||||
if (IsComplexType(p.PropertyType))
|
||||
{
|
||||
var nextType = GetUnderlyingType(p.PropertyType);
|
||||
if (nextType != type) // Prevent infinite recursion for parent/child relations
|
||||
{
|
||||
metaList.AddRange(ScanEntity(nextType, level + 1, currentPath, meta));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return metaList;
|
||||
}
|
||||
|
||||
private static bool IsComplexType(Type type)
|
||||
{
|
||||
if (type.IsPrimitive || type == typeof(string) || type == typeof(Guid) || type == typeof(DateTime) || type == typeof(decimal) || type == typeof(double) || type.IsEnum)
|
||||
return false;
|
||||
|
||||
var underlying = GetUnderlyingType(type);
|
||||
return underlying != type || (!underlying.Namespace?.StartsWith("System") ?? true);
|
||||
}
|
||||
|
||||
private static Type GetUnderlyingType(Type type)
|
||||
{
|
||||
if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(List<>) || type.GetGenericTypeDefinition() == typeof(ICollection<>) || type.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
|
||||
return type.GetGenericArguments()[0];
|
||||
|
||||
if (type.IsArray) return type.GetElementType();
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
private static PropertyMetadata FindBranchRoot(PropertyMetadata meta)
|
||||
{
|
||||
var current = meta;
|
||||
PropertyMetadata collectionRoot = null;
|
||||
|
||||
while (current != null)
|
||||
{
|
||||
if (IsCollection(current.PropertyType))
|
||||
collectionRoot = current;
|
||||
current = current.Parent;
|
||||
}
|
||||
|
||||
return collectionRoot;
|
||||
}
|
||||
|
||||
private static bool IsCollection(Type type) => type != typeof(string) && typeof(IEnumerable).IsAssignableFrom(type);
|
||||
|
||||
private static Dictionary<string, (PropertyMetadata Meta, object Value)> DiscoverBranchFilters(
|
||||
PropertyMetadata branchRoot,
|
||||
List<PropertyMetadata> allMeta,
|
||||
Dictionary<string, object> filterValues,
|
||||
HashSet<string> appliedKeys)
|
||||
{
|
||||
var results = new Dictionary<string, (PropertyMetadata, object)>();
|
||||
|
||||
// Find all metadata items that are descendants of this branch root
|
||||
var descendants = allMeta.Where(m => m.Path.StartsWith(branchRoot.Path + ".")).ToList();
|
||||
|
||||
foreach (var d in descendants)
|
||||
{
|
||||
if (filterValues.TryGetValue(d.Name, out var val) && !appliedKeys.Contains(d.Name))
|
||||
{
|
||||
results[d.Name] = (d, val);
|
||||
}
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
private static IQueryable<T> ApplyBranchFilter<T>(
|
||||
IQueryable<T> query,
|
||||
ParameterExpression rootParam,
|
||||
PropertyMetadata branchRoot,
|
||||
Dictionary<string, (PropertyMetadata Meta, object Value)> branchFilters)
|
||||
{
|
||||
var itemType = GetUnderlyingType(branchRoot.PropertyType);
|
||||
var itemParam = Expression.Parameter(itemType, "t");
|
||||
|
||||
Expression branchExpression = null;
|
||||
|
||||
foreach (var bf in branchFilters.Values)
|
||||
{
|
||||
// Resolve path relative to the collection item
|
||||
// Example: branchRoot is "Translations", bf.Meta.Path is "Translations.Info.Name"
|
||||
// Relative path is "Info.Name"
|
||||
var relativePath = bf.Meta.Path.Substring(branchRoot.Path.Length + 1);
|
||||
var propertyExpr = BuildRelativePropertyExpression(itemParam, relativePath);
|
||||
|
||||
var comparison = BuildComparisonFromExpression(propertyExpr, bf.Value);
|
||||
|
||||
if (comparison != null)
|
||||
{
|
||||
branchExpression = branchExpression == null
|
||||
? comparison
|
||||
: Expression.AndAlso(branchExpression, comparison);
|
||||
}
|
||||
}
|
||||
|
||||
if (branchExpression == null) return query;
|
||||
|
||||
// Build: x => x.Translations.Any(t => t.Info.Name == "..." && t.Language == "...")
|
||||
var anyMethod = typeof(Enumerable).GetMethods()
|
||||
.First(m => m.Name == "Any" && m.GetParameters().Length == 2)
|
||||
.MakeGenericMethod(itemType);
|
||||
|
||||
var collectionExpr = Expression.Property(rootParam, branchRoot.PropertyInfo);
|
||||
var lambda = Expression.Lambda(branchExpression, itemParam);
|
||||
var anyCall = Expression.Call(null, anyMethod, collectionExpr, lambda);
|
||||
|
||||
var finalLambda = Expression.Lambda<Func<T, bool>>(anyCall, rootParam);
|
||||
return query.Where(finalLambda);
|
||||
}
|
||||
|
||||
private static Expression BuildRelativePropertyExpression(Expression param, string path)
|
||||
{
|
||||
Expression expr = param;
|
||||
foreach (var part in path.Split('.'))
|
||||
{
|
||||
expr = Expression.Property(expr, part);
|
||||
}
|
||||
return expr;
|
||||
}
|
||||
|
||||
private static Expression? BuildComparison(Expression param, PropertyInfo prop, object? value)
|
||||
{
|
||||
var propertyExpr = Expression.Property(param, prop);
|
||||
return BuildComparisonFromExpression(propertyExpr, value);
|
||||
}
|
||||
|
||||
private static Expression? BuildComparisonFromExpression(Expression propertyExpr, object? value)
|
||||
{
|
||||
if (value == null) return null;
|
||||
|
||||
if (propertyExpr.Type == typeof(string))
|
||||
{
|
||||
var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) })!;
|
||||
|
||||
// x => x.Property.Contains(value)
|
||||
var searchValue = Expression.Constant(value.ToString() ?? string.Empty, typeof(string));
|
||||
|
||||
return Expression.Call(propertyExpr, containsMethod, searchValue);
|
||||
}
|
||||
|
||||
if (IsCollection(propertyExpr.Type) && GetUnderlyingType(propertyExpr.Type) == typeof(string))
|
||||
{
|
||||
var anyMethod = typeof(Enumerable).GetMethods()
|
||||
.First(m => m.Name == "Any" && m.GetParameters().Length == 2)
|
||||
.MakeGenericMethod(typeof(string));
|
||||
|
||||
var itemParam = Expression.Parameter(typeof(string), "s");
|
||||
var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) })!;
|
||||
|
||||
var searchValue = Expression.Constant(value.ToString() ?? string.Empty, typeof(string));
|
||||
var itemContains = Expression.Call(itemParam, containsMethod, searchValue);
|
||||
|
||||
var lambda = Expression.Lambda(itemContains, itemParam);
|
||||
return Expression.Call(null, anyMethod, propertyExpr, lambda);
|
||||
}
|
||||
|
||||
// Handle Nullable types for equality
|
||||
var memberType = propertyExpr.Type;
|
||||
if (memberType.IsGenericType && memberType.GetGenericTypeDefinition() == typeof(Nullable<>))
|
||||
{
|
||||
propertyExpr = Expression.Convert(propertyExpr, memberType.GetGenericArguments()[0]);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var convertedValue = Convert.ChangeType(value, propertyExpr.Type);
|
||||
return Expression.Equal(propertyExpr, Expression.Constant(convertedValue, propertyExpr.Type));
|
||||
}
|
||||
catch
|
||||
{
|
||||
return Expression.Equal(propertyExpr, Expression.Constant(value, propertyExpr.Type));
|
||||
}
|
||||
}
|
||||
|
||||
private class PropertyMetadata
|
||||
{
|
||||
public string Name { get; set; }
|
||||
public string Path { get; set; }
|
||||
public int Level { get; set; }
|
||||
public PropertyInfo PropertyInfo { get; set; }
|
||||
public Type PropertyType { get; set; }
|
||||
public PropertyMetadata Parent { get; set; }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user