added filter dbo; added filter in crud interface; added npgsql int.ToString method support

Luticate2.Utils/Business/LuCrudBusiness.cs

 using System;
 using System.Collections.Generic;
 using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Interfaces;
             return DataAccess.GetSingleById(id);
         }
 
+
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+            int page = 0, int perPage = int.MaxValue)
+        {
+            return DataAccess.GetMultiple(orderBy, filter, page, perPage);
+        }
+
         public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0,
             int perPage = int.MaxValue)
         {
-            var res = DataAccess.GetMultiple(orderBy, page, perPage);
-            return res;
+            return DataAccess.GetMultiple(orderBy, page, perPage);
         }
 
 

Luticate2.Utils/Controllers/LuCrudController.cs

 using System.Linq;
 using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 
         [HttpGet]
         [Route("[controller]")]
-        public LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        public LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+            int page = 0, int perPage = int.MaxValue)
         {
-            return Handle(Busines.GetMultiple(orderBy, page, perPage));
+            return Handle(Busines.GetMultiple(orderBy, filter, page, perPage));
         }
 
         [HttpPost]

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

 using System.Collections.Generic;
+using Luticate2.Utils.DataAccess.Npgsql;
 using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Middlewares;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators.Internal;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace Luticate2.Utils.Controllers
 {
             return services;
         }
 
+        public static IServiceCollection AddEntityFrameworkNpgsqlLuticate(this IServiceCollection services)
+        {
+            services.TryAdd(new ServiceCollection()
+                .AddScoped<NpgsqlCompositeMethodCallTranslator, NpgsqlCompositeMethodCallTranslatorLuticate>());
+            return services;
+        }
+
         public static IMvcBuilder AddLuticateUtils(this IMvcBuilder builder)
         {
             builder.Services.Configure<MvcOptions>(
-                options => options.ModelBinderProviders.Insert(0, new LuOrderByBinderProvider()));
+                options =>
+                {
+                    options.ModelBinderProviders.Insert(0, new LuOrderByBinderProvider());
+                    options.ModelBinderProviders.Insert(0, new LuFilterBinderProvider());
+                });
             return builder;
         }
 

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using Luticate2.Utils.DataAccess.Npgsql;
 using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Interfaces;
             return exp;
         }
 
+        protected virtual Expression<Func<TModel, bool>> GetFilterExpression(LuFilterDbo filter)
+        {
+            return model => true;
+        }
+
         protected Func<TDboRead, T> GetIdFunc<T>()
         {
             return x => ((dynamic) x).Id;
             return LuResult<T>.Error(LuStatus.NotFound, typeof(TModel).Name + ": Value not found", "");
         }
 
+        protected IQueryable<TModel> GetFilterQuery(LuFilterDbo filter)
+        {
+            return Table.Where(GetFilterExpression(filter));
+        }
+
 
 
 
             return GetMultiple(orderBy, x => true, page, perPage, otherOrderBy);
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+            int page = 0, int perPage = int.MaxValue)
         {
             return Execute(() =>
             {
-                var count = Table.Count();
+                var queryable = GetFilterQuery(filter);
+                var v = new ExpressionVisitorDebugger();
+                v.Visit(queryable.Expression);
+                var count = queryable.Count();
                 IOrderedQueryable<TModel> ordered = null;
                 foreach (var field in orderBy.Fields)
                 {
                     }
                     else
                     {
-                        ordered = field.Asc ? Table.OrderBy(exp) : Table.OrderByDescending(exp);
+                        ordered = field.Asc ? queryable.OrderBy(exp) : queryable.OrderByDescending(exp);
                     }
                 }
 
             });
         }
 
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        {
+            var filter = new LuFilterDbo
+            {
+                Query = ""
+            };
+            return GetMultiple(orderBy, filter, page, perPage);
+        }
+
 
 
         public LuResult<T> Edit<T>(Expression<Func<TModel, bool>> predicate, Action<TModel> update,

Luticate2.Utils/DataAccess/Npgsql/ExpressionVisitorDebugger.cs

+using System.Linq.Expressions;
+
+namespace Luticate2.Utils.DataAccess.Npgsql
+{
+    public class ExpressionVisitorDebugger : ExpressionVisitor
+    {
+        protected override Expression VisitUnary(UnaryExpression node)
+        {
+            return base.VisitUnary(node);
+        }
+
+        protected override Expression VisitBinary(BinaryExpression node)
+        {
+            return base.VisitBinary(node);
+        }
+    }
+}

Luticate2.Utils/DataAccess/Npgsql/NpgsqlCompositeMethodCallTranslatorLuticate.cs

+using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
+using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators.Internal;
+using Microsoft.Extensions.Logging;
+
+namespace Luticate2.Utils.DataAccess.Npgsql
+{
+    public class NpgsqlCompositeMethodCallTranslatorLuticate : NpgsqlCompositeMethodCallTranslator
+    {
+        private static readonly IMethodCallTranslator[] _methodCallTranslators2 =
+        {
+            new NpgsqlIntToStringTranslator()
+        };
+
+        public NpgsqlCompositeMethodCallTranslatorLuticate(ILogger<NpgsqlCompositeMethodCallTranslator> logger) : base(logger)
+        {
+            AddTranslators(_methodCallTranslators2);
+        }
+    }
+}

Luticate2.Utils/DataAccess/Npgsql/NpgsqlIntToStringTranslator.cs

+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Microsoft.EntityFrameworkCore.Query.Expressions;
+using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
+
+namespace Luticate2.Utils.DataAccess.Npgsql
+{
+    public class NpgsqlIntToStringTranslator : IMethodCallTranslator
+    {
+        private readonly Type[] _declaringTypes = {typeof(int), typeof(int?)};
+
+        private readonly string _clrMethodName = "ToString";
+
+        public Expression Translate(MethodCallExpression methodCallExpression)
+        {
+            foreach (var declaringType in _declaringTypes)
+            {
+                var methodInfo = declaringType.GetTypeInfo()
+                    .GetDeclaredMethods(_clrMethodName).SingleOrDefault(m => !m.GetParameters().Any());
+                if (methodInfo != null && declaringType.IsAssignableFrom(methodCallExpression.Object.Type))
+                {
+                    return new ExplicitCastExpression(methodCallExpression.Object, typeof(string));
+                }
+            }
+
+            return null;
+        }
+    }
+}

Luticate2.Utils/Dbo/Filter/LuFilterBinder.cs

+using System.Threading.Tasks;
+using Luticate2.Utils.Dbo.Result;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+
+namespace Luticate2.Utils.Dbo.Filter
+{
+    public class LuFilterBinder : IModelBinder
+    {
+        public static LuResult<LuFilterDbo> FromString(string data)
+        {
+            if (data == null)
+            {
+                data = "";
+            }
+            data = data.Trim();
+            var dbo = new LuFilterDbo
+            {
+                Query = data
+            };
+            return LuResult<LuFilterDbo>.Ok(dbo);
+        }
+
+        public Task BindModelAsync(ModelBindingContext bindingContext)
+        {
+            var messageTypeResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
+            var res = FromString(messageTypeResult.FirstValue);
+            if (res)
+            {
+                bindingContext.Result = ModelBindingResult.Success(res.Data);
+            }
+            else
+            {
+                bindingContext.Result = ModelBindingResult.Failed();
+            }
+            return Task.FromResult(0);
+        }
+    }
+
+    public class LuFilterBinderProvider : IModelBinderProvider
+    {
+        public IModelBinder GetBinder(ModelBinderProviderContext context)
+        {
+            if (context.Metadata.ModelType == typeof(LuFilterDbo))
+            {
+                return new LuFilterBinder();
+            }
+            return null;
+        }
+    }
+}

Luticate2.Utils/Dbo/Filter/LuFilterDbo.cs

 {
     public class LuFilterDbo
     {
-
+        public string Query { get; set; }
     }
 }

Luticate2.Utils/Interfaces/ILuCrudInterface.cs

 using System.Collections.Generic;
 using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.Result;
 
         LuResult<TDboRead> GetSingleById(long id);
 
 
+        LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+            int page = 0, int perPage = int.MaxValue);
+
         LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue);
 
 

Test/Utils/DataAccess/LuUtilsPartialContext.cs

+using System;
+using Microsoft.EntityFrameworkCore;
+using Luticate2.Auth.DataAccess.Models;
+using Test.Utils.DataAccess.Models;
+
+namespace Test.Utils.DataAccess
+{
+    public partial class LuUtilsDbContext
+    {
+    }
+}

Test/Utils/DataAccess/LuUtilsPkBigSerialDataAccess.cs

-using Luticate2.Utils.DataAccess;
+using System;
+using System.Linq.Expressions;
+using Luticate2.Utils.DataAccess;
+using Luticate2.Utils.Dbo.Filter;
 using Test.Utils.DataAccess.Models;
 using Test.Utils.Dbo.PkBigSerial;
 
                 SomeText = model.some_text
             };
         }
+
+        protected override Expression<Func<pk_bigserial, bool>> GetFilterExpression(LuFilterDbo filter)
+        {
+            var query = filter.Query.ToLower();
+            return model => model.some_text.ToLower().Contains(query) || model.some_int.ToString().Contains(query);
+        }
     }
 }

Test/Utils/DataAccess/LuUtilsPkGuidDataAccess.cs

-using Luticate2.Utils.DataAccess;
+using System;
+using System.Linq.Expressions;
+using Luticate2.Utils.DataAccess;
+using Luticate2.Utils.Dbo.Filter;
 using Test.Utils.DataAccess.Models;
 using Test.Utils.Dbo.PkGuid;
 
                 SomeText = model.some_text
             };
         }
+
+        protected override Expression<Func<pk_guid, bool>> GetFilterExpression(LuFilterDbo filter)
+        {
+            var query = filter.Query.ToLower();
+            return model => model.some_text.ToLower().Contains(query) || model.some_int.ToString().Contains(query);
+        }
     }
 }

WebTest/Startup.cs

 using Luticate2.Auth.Controllers;
+using Luticate2.Utils.Controllers;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.EntityFrameworkCore;
 
             services.AddTransient<PkGuidBusiness>();
             services.AddTransient<LuUtilsPkGuidDataAccess>();
-            services.AddDbContext<LuUtilsDbContext>(options => options.UseNpgsql(Tests.ConnectionString));
+            services.AddDbContext<LuUtilsDbContext>(options =>
+            {
+                options.UseNpgsql(Tests.ConnectionString);
+                options.UseInternalServiceProvider(new ServiceCollection()
+                    .AddEntityFrameworkNpgsqlLuticate()
+                    .AddEntityFrameworkNpgsql()
+                    .BuildServiceProvider());
+            });
 
             services.AddMvc()
                 .AddLuticateAuth();