fix: change the AbstractEntitySearchService to use reflection to work with mongo v3 linq provider

Firebend.AutoCrud.ChangeTracking.EntityFramework/Implementations/EntityFrameworkChangeTrackingReadService.cs

@@ -44,12 +44,7 @@ public async Task<EntityPagedResponse<ChangeTrackingEntity<TEntityKey, TEntity>>
         {
             query = query.Where(x => x.EntityId.Equals(searchRequest.EntityId));
 
-            var filter = GetSearchExpression(searchRequest);
-
-            if (filter != null)
-            {
-                query = query.Where(filter);
-            }
+            query = GetSearchExpressions(searchRequest).Aggregate(query, (current, expression) => current.Where(expression));
 
             if (_searchHandler != null)
             {

Firebend.AutoCrud.ChangeTracking.Mongo/Implementations/MongoChangeTrackingReadRepository.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Firebend.AutoCrud.ChangeTracking.Interfaces;
@@ -51,12 +52,7 @@ public async Task<EntityPagedResponse<ChangeTrackingEntity<TEntityKey, TEntity>>
 
         query = query.Where(x => x.EntityId.Equals(searchRequest.EntityId));
 
-        var filter = GetSearchExpression(searchRequest);
-
-        if (filter != null)
-        {
-            query = query.Where(filter);
-        }
+        query = GetSearchExpressions(searchRequest).Aggregate(query, (current, expression) => current.Where(expression));
 
         if (searchRequest.OrderBy == null)
         {

Firebend.AutoCrud.Core/Abstractions/Services/AbstractEntitySearchService.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Reflection;
 using Firebend.AutoCrud.Core.Extensions;
 using Firebend.AutoCrud.Core.Implementations;
 using Firebend.AutoCrud.Core.Interfaces.Models;
@@ -11,61 +12,82 @@ namespace Firebend.AutoCrud.Core.Abstractions.Services;
 public abstract class AbstractEntitySearchService<TEntity, TSearch> : BaseDisposable
     where TSearch : IEntitySearchRequest
 {
-    protected Expression<Func<TEntity, bool>> GetSearchExpression(TSearch search, Expression<Func<TEntity, bool>> customFilter = null)
-    {
-        var functions = new List<Expression<Func<TEntity, bool>>>();
+    private Type _myType;
+    private MethodInfo _yieldDateFiltersMethodInfo;
+    private MethodInfo _yieldActiveFiltersMethodInfo;
 
-        if (search is IActiveEntitySearchRequest { IsDeleted: not null } activeEntitySearchRequest)
-        {
-            Expression<Func<IActiveEntity, bool>> expression = activeEntitySearchRequest.IsDeleted.Value
-                ? x => x.IsDeleted
-                : x => !x.IsDeleted;
+    private Type MyType => _myType ??= typeof(AbstractEntitySearchService<TEntity, TSearch>);
 
-            functions.Add(Expression.Lambda<Func<TEntity, bool>>(expression.Body, expression.Parameters));
-        }
+    private MethodInfo YieldDateFiltersMethodInfo => _yieldDateFiltersMethodInfo ??= MyType
+        .GetMethod(nameof(YieldDateFilters), BindingFlags.Static | BindingFlags.NonPublic)
+        ?.MakeGenericMethod(typeof(TEntity));
+
+    private MethodInfo YieldActiveFiltersMethodInfo => _yieldActiveFiltersMethodInfo ??= MyType
+        .GetMethod(nameof(YieldActiveFilters), BindingFlags.Static | BindingFlags.NonPublic)
+        ?.MakeGenericMethod(typeof(TEntity));
 
-        if (search is IModifiedEntitySearchRequest modifiedEntitySearchRequest)
+
+    protected IEnumerable<Expression<Func<TEntity, bool>>> GetSearchExpressions(TSearch search)
+    {
+        if (search is IActiveEntitySearchRequest { IsDeleted: not null })
         {
-            if (modifiedEntitySearchRequest.CreatedStartDate.HasValue)
+            foreach (var func in InvokeFiltering(YieldActiveFiltersMethodInfo, search))
             {
-                Expression<Func<IModifiedEntity, bool>> expression =
-                    x => x.CreatedDate >= modifiedEntitySearchRequest.CreatedStartDate;
-
-                functions.Add(Expression.Lambda<Func<TEntity, bool>>(expression.Body, expression.Parameters));
+                yield return func;
             }
+        }
 
-            if (modifiedEntitySearchRequest.CreatedEndDate.HasValue)
+        if (search is IModifiedEntitySearchRequest)
+        {
+            foreach (var func in InvokeFiltering(YieldDateFiltersMethodInfo, search))
             {
-                Expression<Func<IModifiedEntity, bool>> expression =
-                    x => x.CreatedDate <= modifiedEntitySearchRequest.CreatedEndDate;
-
-                functions.Add(Expression.Lambda<Func<TEntity, bool>>(expression.Body, expression.Parameters));
+                yield return func;
             }
+        }
+    }
 
-            if (modifiedEntitySearchRequest.ModifiedStartDate.HasValue)
-            {
-                Expression<Func<IModifiedEntity, bool>> expression =
-                    x => x.ModifiedDate >= modifiedEntitySearchRequest.ModifiedStartDate;
+    private IEnumerable<Expression<Func<TEntity, bool>>> InvokeFiltering(MethodInfo method, TSearch search)
+    {
+        var invoked = method.Invoke(this, [search]);
+        var enumerable = invoked as IEnumerable<Expression<Func<TEntity, bool>>>;
+        return enumerable;
+    }
 
-                functions.Add(Expression.Lambda<Func<TEntity, bool>>(expression.Body, expression.Parameters));
-            }
+    private static IEnumerable<Expression<Func<T, bool>>> YieldDateFilters<T>(
+        IModifiedEntitySearchRequest modifiedEntitySearchRequest)
+        where T : TEntity, IModifiedEntity
+    {
+        if (modifiedEntitySearchRequest.CreatedStartDate.HasValue)
+        {
+            yield return x => x.CreatedDate >= modifiedEntitySearchRequest.CreatedStartDate;
+        }
 
-            if (modifiedEntitySearchRequest.ModifiedEndDate.HasValue)
-            {
-                Expression<Func<IModifiedEntity, bool>> expression =
-                    x => x.ModifiedDate <= modifiedEntitySearchRequest.ModifiedEndDate;
+        if (modifiedEntitySearchRequest.CreatedEndDate.HasValue)
+        {
+            yield return x => x.CreatedDate <= modifiedEntitySearchRequest.CreatedEndDate;
+        }
 
-                functions.Add(Expression.Lambda<Func<TEntity, bool>>(expression.Body, expression.Parameters));
-            }
+        if (modifiedEntitySearchRequest.ModifiedStartDate.HasValue)
+        {
+            yield return x => x.ModifiedDate >= modifiedEntitySearchRequest.ModifiedStartDate;
         }
 
-        if (customFilter != null)
+        if (modifiedEntitySearchRequest.ModifiedEndDate.HasValue)
         {
-            functions.Add(customFilter);
+            yield return x => x.ModifiedDate <= modifiedEntitySearchRequest.ModifiedEndDate;
         }
+    }
 
-        return functions.Aggregate(
-            default(Expression<Func<TEntity, bool>>),
-            (aggregate, filter) => aggregate.AndAlso(filter));
+    private static IEnumerable<Expression<Func<T, bool>>> YieldActiveFilters<T>(
+        IActiveEntitySearchRequest activeEntitySearchRequest)
+        where T : IActiveEntity, TEntity
+    {
+        var isDeleted = activeEntitySearchRequest.IsDeleted.GetValueOrDefault();
+
+        yield return isDeleted switch
+        {
+            true => x => x.IsDeleted,
+            false => x => !x.IsDeleted
+        };
     }
 }

Firebend.AutoCrud.Core/Extensions/OrderByExtensions.cs

@@ -56,7 +56,7 @@ public static (Expression<Func<T, object>> order, bool ascending)[] ToOrderByGro
     {
         if (source is null || source.Length <= 0)
         {
-            return Array.Empty<(Expression<Func<T, object>> order, bool ascending)>();
+            return [];
         }
 
         return source

Firebend.AutoCrud.EntityFramework/Services/EntityFrameworkEntitySearchService.cs

@@ -64,12 +64,7 @@ public async Task<EntityPagedResponse<TEntity>> PageAsync(TSearch request,
 
         await using (context)
         {
-            var expression = GetSearchExpression(request);
-
-            if (expression != null)
-            {
-                query = query.Where(expression);
-            }
+            query = GetSearchExpressions(request).Aggregate(query, (current, expression) => current.Where(expression));
 
             if (_searchHandler != null)
             {

Firebend.AutoCrud.IntegrationTests/BaseTest.cs

@@ -193,6 +193,10 @@ private async Task PageAsync()
             .SetQueryParam("pageSize", 10)
             .SetQueryParam("isDeleted", "false")
             .SetQueryParam("orderBy", "createdDate:desc")
+            .SetQueryParam("CreatedStartDate", "1968-08-09")
+            .SetQueryParam("CreatedEndDate", "2068-08-09")
+            .SetQueryParam("ModifiedStartDate", "1968-08-09")
+            .SetQueryParam("ModifiedEndDate", "2068-08-09")
             .SetQueryParam("doCount", true)
             .GetAsync();
 

Firebend.AutoCrud.Mongo/Services/MongoEntitySearchService.cs

@@ -65,12 +65,7 @@ public async Task<EntityPagedResponse<TEntity>> PageAsync(TSearch request, IEnti
 
         var query = await _readClient.GetQueryableAsync(firstStageFilter, entityTransaction, cancellationToken);
 
-        var expression = GetSearchExpression(request);
-
-        if (expression != null)
-        {
-            query = query.Where(expression);
-        }
+        query = GetSearchExpressions(request).Aggregate(query, (current, expression) => current.Where(expression));
 
         var paged = await _readClient.GetPagedResponseAsync(query, request, cancellationToken);