LuObjectConverter stuff

.idea/.idea.luticate2/.idea/contentModel.xml

@@ -13,9 +13,6 @@
       <e p="Luticate2.Auth" t="IncludeRecursive">
         <e p="Business" t="Include">
           <e p="Auth" t="Include">
-            <e p="DMEC" t="Include">
-              <e p="LuDMECGroupsToModel.cs" t="Include" />
-            </e>
             <e p="LuGroupsBusiness.cs" t="Include" />
             <e p="PartialObjectCopier" t="Include">
               <e p="LuPOCGroupsToDbo.cs" t="Include" />
@@ -26,19 +23,22 @@
           <e p="Crud" t="Include">
             <e p="LuEfCrudBusiness.cs" t="Include" />
           </e>
-          <e p="Fields" t="Include">
-            <e p="DMEC" t="Include">
-              <e p="LuExpressionConverterEnumerable.cs" t="Include" />
-              <e p="LuExpressionConverterIdentity.cs" t="Include" />
-              <e p="LuExpressionConverterOptions.cs" t="Include" />
-              <e p="LuExpressionConverterStaticMethods.cs" t="Include" />
-            </e>
-            <e p="LuExpressionConverter.cs" t="Include" />
+          <e p="ExpressionConverter" t="Include">
+            <e p="LuExpressionConverterOptions.cs" t="Include" />
             <e p="LuExpressionConverterVisitor.cs" t="Include" />
+            <e p="LuExpressionParamReplaceVisitor.cs" t="Include" />
+          </e>
+          <e p="Fields" t="Include">
             <e p="LuFieldsExtensions.cs" t="Include" />
             <e p="LuPartialFieldsParser.cs" t="Include" />
           </e>
           <e p="LuExpressionUtils.cs" t="Include" />
+          <e p="ObjectConverter" t="Include">
+            <e p="LuObjectConverterDescriptor.cs" t="Include" />
+            <e p="LuObjectConverterDescriptorDbSet.cs" t="Include" />
+            <e p="LuObjectConverterDescriptorEnumerable.cs" t="Include" />
+            <e p="LuObjectConverterDescriptorIdentity.cs" t="Include" />
+          </e>
           <e p="Pagination" t="Include">
             <e p="LuFilterParser.cs" t="Include" />
             <e p="LuOrderByParser.cs" t="Include" />
@@ -99,6 +99,7 @@
         <e p="Interfaces" t="Include">
           <e p="ILuCrud.cs" t="Include" />
           <e p="ILuExpressionConverter.cs" t="Include" />
+          <e p="ILuObjectConverterDescriptor.cs" t="Include" />
           <e p="ILuOrderByObjectType.cs" t="Include" />
           <e p="ILuPartialObjectCopier.cs" t="Include" />
         </e>
@@ -136,6 +137,10 @@
             <e p="LuFieldDboTests.cs" t="Include" />
           </e>
           <e p="LuExpressionUtilsTests.cs" t="Include" />
+          <e p="ObjectConverter" t="Include">
+            <e p="ObjectConverterTests.cs" t="Include" />
+            <e p="Objects.cs" t="Include" />
+          </e>
           <e p="Pagination" t="Include">
             <e p="LuFilterTests.cs" t="Include" />
           </e>

Luticate2.Auth.ConsoleSample/Program.cs

@@ -1,9 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Luticate2.Auth.Business.Auth;
-using Luticate2.Auth.Business.Auth.DMEC;
 using Luticate2.Auth.Business.Auth.PartialObjectCopier;
-using Luticate2.Auth.Business.Fields.DMEC;
 using Luticate2.Auth.ConsoleSample.Commands;
 using Luticate2.Auth.DataAccess;
 using Luticate2.Auth.DataAccess.Models;
@@ -33,12 +31,12 @@ namespace Luticate2.Auth.ConsoleSample
     {
         public static IServiceProvider ServiceProvider;
 
-        protected static void AddILuExpressionConverter<TTypeFrom, TTypeTo, TTypeImpl>(IServiceCollection services)
-            where TTypeImpl : class, ILuExpressionConverter<TTypeFrom, TTypeTo>
-        {
-            services.AddSingleton<ILuExpressionConverter<TTypeFrom, TTypeTo>, TTypeImpl>();
-            services.TryAddSingleton<ILuExpressionConverter<TTypeFrom>, TTypeImpl>();
-        }
+//        protected static void AddILuExpressionConverter<TTypeFrom, TTypeTo, TTypeImpl>(IServiceCollection services)
+//            where TTypeImpl : class, ILuExpressionConverter<TTypeFrom, TTypeTo>
+//        {
+//            services.AddSingleton<ILuExpressionConverter<TTypeFrom, TTypeTo>, TTypeImpl>();
+//            services.TryAddSingleton<ILuExpressionConverter<TTypeFrom>, TTypeImpl>();
+//        }
         
         static void Main(string[] args)
         {
@@ -52,10 +50,10 @@ namespace Luticate2.Auth.ConsoleSample
 
 
 //            services.AddSingleton<ILuDboModelExpressionConverter<TestDbo1, TestModel1>, LuDMECTest1>();
-            AddILuExpressionConverter<LuGroupDbo, LuGroups, LuDMECGroupsToModel>(services);
-            AddILuExpressionConverter<string, string, LuExpressionConverterIdentity<string>>(services);
-            AddILuExpressionConverter<Guid, Guid, LuExpressionConverterIdentity<Guid>>(services);
-            AddILuExpressionConverter<bool, bool, LuExpressionConverterIdentity<bool>>(services);
+//            AddILuExpressionConverter<LuGroupDbo, LuGroups, LuDMECGroupsToModel>(services);
+//            AddILuExpressionConverter<string, string, LuExpressionConverterIdentity<string>>(services);
+//            AddILuExpressionConverter<Guid, Guid, LuExpressionConverterIdentity<Guid>>(services);
+//            AddILuExpressionConverter<bool, bool, LuExpressionConverterIdentity<bool>>(services);
 
 
 //            services.AddSingleton<ILuFieldsExpressions<LuObjectsMetadataDbo, LuObjectsMetadata>, LuFieldsExpressionsLuMetadataDboLuMetadata>();

Luticate2.Auth.Tests/Business/Fields/LuDboModelExpressionConverterTests.cs

@@ -4,7 +4,7 @@ using System.Linq.Expressions;
 using System.Reflection;
 using Luticate2.Auth.Business;
 using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Business.Fields.DMEC;
+using Luticate2.Auth.Business.ObjectConverter;
 using Luticate2.Auth.Dbo;
 using Luticate2.Auth.Dbo.Result;
 using Luticate2.Auth.Interfaces;
@@ -13,6 +13,13 @@ using Xunit;
 
 namespace Luticate2.Auth.Tests.Business.Fields
 {
+    public static class StaticDbo
+    {
+        public static bool StaticField;
+
+        public static bool StaticProperty { get; set; }
+    }
+
     public class TestDbo1
     {
         public Guid Id { get; set; }
@@ -20,6 +27,11 @@ namespace Luticate2.Auth.Tests.Business.Fields
         public string Name { get; set; }
 
         public IList<TestDbo2> TestDbo2s { get; set; }
+
+        public string ToString()
+        {
+            throw new NotImplementedException();
+        }
     }
 
     public class TestDbo2
@@ -28,84 +40,60 @@ namespace Luticate2.Auth.Tests.Business.Fields
 
         public string Name { get; set; }
 
+        public string NameVirtual { get; set; }
+
         public TestDbo1 TestDbo1 { get; set; }
+
+        public TestDbo2 Parent { get; set; }
+
+        public TestModel1 Unused { get; set; }
     }
 
     public class TestModel1
     {
-        public Guid Id { get; set; }
+        public Guid id { get; set; }
 
-        public string Name { get; set; }
+        public string name { get; set; }
 
-        public ICollection<TestModel2> TestModel2 { get; set; }
+        public ICollection<TestModel2> test_model2 { get; set; }
     }
 
     public class TestModel2
     {
-        public Guid Id { get; set; }
+        public Guid id { get; set; }
 
-        public string Name { get; set; }
+        public string name { get; set; }
 
-        public Guid TestModel1Id { get; set; }
+        public Guid test_model1_id { get; set; }
 
-        public TestModel1 TestModel1 { get; set; }
+        public TestModel1 test_model1 { get; set; }
+
+        public TestModel2 parent { get; set; }
     }
 
-    public class LuDMECTest1 : LuExpressionConverter<TestDbo1, TestModel1>
+    public class LuDMECTest1 : LuObjectConverterDescriptor<TestDbo1, TestModel1>
     {
-        public LuDMECTest1(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression> ConvertInternal(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
+        public LuDMECTest1()
         {
-            var expression = expressions.Peek();
-            if (expression is MemberExpression memberExpression)
-            {
-                if (MemberMatch(x => x.Id, memberExpression))
-                {
-                    return MakeMemberAccess(x => x.Id, expressions, baseExpression, options);
-                }
-                if (MemberMatch(x => x.Name, memberExpression))
-                {
-                    return MakeMemberAccess(x => x.Name, expressions, baseExpression, options);
-                }
-                if (MemberMatch(x => x.TestDbo2s, memberExpression))
-                {
-                    return MakeMemberAccess(x => x.TestModel2, expressions, baseExpression, options);
-                }
-            }
-
-            return base.ConvertInternal(expressions, baseExpression, options);
+            AddMemberConverter(x => x.Id, y => y.id, PropertyType.Value);
+            AddMemberConverter(x => x.Name, y => y.name, PropertyType.Value);
+            AddMemberConverter(x => x.TestDbo2s, y => y.test_model2, PropertyType.Object);
+            AddStaticMethodConverter(
+                (Expression<Func<TestDbo1, string>>)(x => x.ToString()),
+                (Expression<Func<TestModel1, string>>)(x => x.id + ": " + x.name)
+            );
         }
     }
 
-    public class LuDMECTest2 : LuExpressionConverter<TestDbo2, TestModel2>
+    public class LuDMECTest2 : LuObjectConverterDescriptor<TestDbo2, TestModel2>
     {
-        public LuDMECTest2(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression> ConvertInternal(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
+        public LuDMECTest2()
         {
-            var expression = expressions.Peek();
-            if (expression is MemberExpression memberExpression)
-            {
-                if (MemberMatch(x => x.Id, memberExpression))
-                {
-                    return MakeMemberAccess(x => x.Id, expressions, baseExpression, options);
-                }
-                if (MemberMatch(x => x.Name, memberExpression))
-                {
-                    return MakeMemberAccess(x => x.Name, expressions, baseExpression, options);
-                }
-                if (MemberMatch(x => x.TestDbo1, memberExpression))
-                {
-                    return MakeMemberAccess(x => x.TestModel1, expressions, baseExpression, options);
-                }
-            }
-
-            return base.ConvertInternal(expressions, baseExpression, options);
+            AddMemberConverter(x => x.Id, y => y.id, PropertyType.Value);
+            AddMemberConverter(x => x.Name, y => y.name, PropertyType.Value);
+            AddMemberConverter(x => x.NameVirtual, y => y.name + " " + y.name, PropertyType.Value);
+            AddMemberConverter(x => x.TestDbo1, y => y.test_model1, PropertyType.Object);
+            AddMemberConverter(x => x.Parent, y => y.parent, PropertyType.Object);
         }
     }
 
@@ -114,10 +102,10 @@ namespace Luticate2.Auth.Tests.Business.Fields
         public IServiceProvider GetServiceProvider()
         {
             var services = new ServiceCollection();
-            services.AddSingleton<ILuExpressionConverter<TestDbo1, TestModel1>, LuDMECTest1>();
-            services.AddSingleton<ILuExpressionConverter<TestDbo2, TestModel2>, LuDMECTest2>();
-            services.AddSingleton<ILuExpressionConverter<string, string>, LuExpressionConverterIdentity<string>>();
-            services.AddSingleton<ILuExpressionConverter<Guid, Guid>, LuExpressionConverterIdentity<Guid>>();
+//            services.AddSingleton<ILuExpressionConverter<TestDbo1, TestModel1>, LuDMECTest1>();
+//            services.AddSingleton<ILuExpressionConverter<TestDbo2, TestModel2>, LuDMECTest2>();
+//            services.AddSingleton<ILuExpressionConverter<string, string>, LuExpressionConverterIdentity<string>>();
+//            services.AddSingleton<ILuExpressionConverter<Guid, Guid>, LuExpressionConverterIdentity<Guid>>();
 
             var serviceProvider = services.BuildServiceProvider();
             return serviceProvider;

Luticate2.Auth.Tests/Business/LuExpressionUtilsTests.cs

@@ -1,4 +1,6 @@
-using System.Linq;
+using System;
+using System.Linq;
+using System.Linq.Expressions;
 using Luticate2.Auth.Business;
 using Xunit;
 
@@ -25,7 +27,7 @@ namespace Luticate2.Auth.Tests.Business
         [Fact]
         public void GetSingleMemberFromExpression1()
         {
-            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, string>(x => x.MyString);
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression((Expression<Func<TestDbo1, string>>)(x => x.MyString));
             Assert.NotNull(memberInfo);
             Assert.Equal("MyString", memberInfo.Name);
         }
@@ -33,7 +35,7 @@ namespace Luticate2.Auth.Tests.Business
         [Fact]
         public void GetSingleMemberFromExpression2()
         {
-            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, TestDbo2>(x => x.TestDbo2);
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression((Expression<Func<TestDbo1, TestDbo2>>)(x => x.TestDbo2));
             Assert.NotNull(memberInfo);
             Assert.Equal("TestDbo2", memberInfo.Name);
         }
@@ -41,28 +43,28 @@ namespace Luticate2.Auth.Tests.Business
         [Fact]
         public void GetSingleMemberFromExpression3()
         {
-            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, TestDbo1>(x => x);
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression((Expression<Func<TestDbo1, TestDbo1>>)(x => x));
             Assert.Null(memberInfo);
         }
         
         [Fact]
         public void GetSingleMemberFromExpression4()
         {
-            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, int>(x => 42);
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression((Expression<Func<TestDbo1, int>>)(x => 42));
             Assert.Null(memberInfo);
         }
         
         [Fact]
         public void GetSingleMemberFromExpression5()
         {
-            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, int>(x => x.TestDbo2.MyInt);
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression((Expression<Func<TestDbo1, int>>)(x => x.TestDbo2.MyInt));
             Assert.Null(memberInfo);
         }
         
         [Fact]
         public void GetSingleMemberFromExpression6()
         {
-            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, int>(x => x.TestDbo2.RecursiveObject.MyInt);
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression((Expression<Func<TestDbo1, int>>)(x => x.TestDbo2.RecursiveObject.MyInt));
             Assert.Null(memberInfo);
         }
 

Luticate2.Auth.Tests/Business/ObjectConverter/ObjectConverterTests.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.ExpressionConverter;
+using Luticate2.Auth.Business.ObjectConverter;
+using Luticate2.Auth.Interfaces;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Luticate2.Auth.Tests.Business.ObjectConverter
+{
+    public class ObjectConverterTests
+    {
+
+        protected IServiceProvider GetServiceProvider()
+        {
+            var typeILuObjectConverterDescriptor = typeof(ILuObjectConverterDescriptor<,>);
+            var typeILuObjectConverterDescriptorEnumerable =
+                typeILuObjectConverterDescriptor.MakeGenericType(typeof(Enumerable), typeof(Enumerable));
+
+            var services = new ServiceCollection();
+            services.AddSingleton<ILuObjectConverterDescriptorIdentity, LuObjectConverterDescriptorIdentity>();
+            services.AddSingleton(typeILuObjectConverterDescriptorEnumerable, typeof(LuObjectConverterDescriptorEnumerable));
+            services.AddSingleton<ILuObjectConverterDescriptor<TestDbo1, TestModel1>, LuOcdTest1>();
+            services.AddSingleton<ILuObjectConverterDescriptor<TestDbo2, TestModel2>, LuOcdTest2>();
+
+            var serviceProvider = services.BuildServiceProvider();
+            return serviceProvider;
+        }
+
+        protected LuExpressionConverterOptions GetConverterOptions()
+        {
+            var options = new LuExpressionConverterOptions
+            {
+                Parameters = new Dictionary<ParameterExpression, Expression>(),
+                Types = new Dictionary<Type, Type>
+                {
+                    {typeof(TestDbo1), typeof(TestModel1)},
+                    {typeof(TestDbo2), typeof(TestModel2)}
+                }
+            };
+            return options;
+        }
+
+        protected LuExpressionConverterVisitor GetConverter()
+        {
+            return new LuExpressionConverterVisitor(GetConverterOptions(), GetServiceProvider());
+        }
+
+        [Fact]
+        public void TestSimpleProperty1()
+        {
+            Expression<Func<TestDbo2, Guid>> expDbo = (x => x.TestDbo1.Id);
+            Expression<Func<TestModel2, Guid>> expModel = (Param_0 => Param_0.test_model1.id);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleProperty2()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Id == Guid.Empty);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.id == Guid.Empty);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleProperty3()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Length == 2);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Length == 2);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticProperty1()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => (x.TestDbo1.Name == "42") == StaticDbo.StaticField);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => (Param_0.test_model1.name == "42") == StaticDbo.StaticField);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticProperty2()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => (x.TestDbo1.Name == "42") == StaticDbo.StaticProperty);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => (Param_0.test_model1.name == "42") == StaticDbo.StaticProperty);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestVirtualProperty1()
+        {
+            Expression<Func<TestDbo2, string>> expDbo = (x => x.NameVirtual);
+            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.name + " " + Param_0.name);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestVirtualProperty2()
+        {
+            Expression<Func<TestDbo2, string>> expDbo = (x => x.Parent.NameVirtual);
+            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.parent.name + " " + Param_0.parent.name);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticValue1()
+        {
+            Expression<Func<TestDbo2, int>> expDbo = (x => 0);
+            Expression<Func<TestModel2, int>> expModel = (Param_0 => 0);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticValue2()
+        {
+            Expression<Func<TestDbo2, TestDbo2>> expDbo = (x => x);
+            Expression<Func<TestModel2, TestModel2>> expModel = (Param_0 => Param_0);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticValue3()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => StaticDbo.StaticField);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => StaticDbo.StaticField);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestComplexExpression1()
+        {
+            Expression<Func<TestDbo2, int>> expDbo = (x => (x.Name + " " + x.Name).Length);
+            Expression<Func<TestModel2, int>> expModel = (Param_0 => (Param_0.name + " " + Param_0.name).Length);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestComplexExpression2()
+        {
+            Expression<Func<TestDbo2, int>> expDbo = (x => (x.NameVirtual + " " + x.Name).Length);
+            Expression<Func<TestModel2, int>> expModel = (Param_0 => (Param_0.name + " " + Param_0.name + " " + Param_0.name).Length);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleMethodSimpleArg1()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.Name.Contains("s"));
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.name.Contains("s"));
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleMethodSimpleArg2()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Contains("s"));
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Contains("s"));
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleMethodSimpleArg3()
+        {
+            Expression<Func<TestDbo2, string>> expDbo = (x => x.TestDbo1.ToString());
+            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.test_model1.id + ": " + Param_0.test_model1.name);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleMethodAdvArg1()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Contains(x.Name));
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Contains(Param_0.name));
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestAdvMethodSimpleArg1()
+        {
+            Expression<Func<TestDbo1, bool>> expDbo = (x => x.TestDbo2s.Any());
+            Expression<Func<TestModel1, bool>> expModel = (Param_0 => Param_0.test_model2.Any());
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestAdvMethodAdvArg1()
+        {
+            Expression<Func<TestDbo1, bool>> expDbo = (x => x.TestDbo2s.Any(y => y.Name.Contains(x.Name + "s")));
+            Expression<Func<TestModel1, bool>> expModel = (Param_0 => Param_0.test_model2.Any(Param_1 => Param_1.name.Contains(Param_0.name + "s")));
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+    }
+}

Luticate2.Auth.Tests/Business/ObjectConverter/Objects.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.ObjectConverter;
+
+namespace Luticate2.Auth.Tests.Business.ObjectConverter
+{
+    public static class StaticDbo
+    {
+        public static bool StaticField;
+
+        public static bool StaticProperty { get; set; }
+    }
+
+    public class TestDbo1
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+
+        public IList<TestDbo2> TestDbo2s { get; set; }
+
+        public string ToString()
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    public class TestDbo2
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+
+        public string NameVirtual { get; set; }
+
+        public TestDbo1 TestDbo1 { get; set; }
+
+        public TestDbo2 Parent { get; set; }
+
+        public TestModel1 Unused { get; set; }
+    }
+
+    public class TestModel1
+    {
+        public Guid id { get; set; }
+
+        public string name { get; set; }
+
+        public ICollection<TestModel2> test_model2 { get; set; }
+    }
+
+    public class TestModel2
+    {
+        public Guid id { get; set; }
+
+        public string name { get; set; }
+
+        public Guid test_model1_id { get; set; }
+
+        public TestModel1 test_model1 { get; set; }
+
+        public TestModel2 parent { get; set; }
+    }
+
+    public class LuOcdTest1 : LuObjectConverterDescriptor<TestDbo1, TestModel1>
+    {
+        public LuOcdTest1()
+        {
+            AddMemberConverter(x => x.Id, y => y.id, PropertyType.Value);
+            AddMemberConverter(x => x.Name, y => y.name, PropertyType.Value);
+            AddMemberConverter(x => x.TestDbo2s, y => y.test_model2, PropertyType.Object);
+            AddStaticMethodConverter(
+                (Expression<Func<TestDbo1, string>>)(x => x.ToString()),
+                (Expression<Func<TestModel1, string>>)(x => x.id + ": " + x.name)
+            );
+        }
+    }
+
+    public class LuOcdTest2 : LuObjectConverterDescriptor<TestDbo2, TestModel2>
+    {
+        public LuOcdTest2()
+        {
+            AddMemberConverter(x => x.Id, y => y.id, PropertyType.Value);
+            AddMemberConverter(x => x.Name, y => y.name, PropertyType.Value);
+            AddMemberConverter(x => x.NameVirtual, y => y.name + " " + y.name, PropertyType.Value);
+            AddMemberConverter(x => x.TestDbo1, y => y.test_model1, PropertyType.Object);
+            AddMemberConverter(x => x.Parent, y => y.parent, PropertyType.Object);
+        }
+    }
+}

Luticate2.Auth.Tests/RandomTests.cs

@@ -1,12 +1,13 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Business.Fields.DMEC;
+using Luticate2.Auth.Business.ExpressionConverter;
+using Luticate2.Auth.Business.ObjectConverter;
+using Luticate2.Auth.DataAccess.Models;
 using Luticate2.Auth.Interfaces;
 using Luticate2.Auth.Tests.Business.Fields;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection.Extensions;
 using Xunit;
 
 namespace Luticate2.Auth.Tests
@@ -44,131 +45,21 @@ namespace Luticate2.Auth.Tests
 //            Assert.Equal(2, list.Count);
 //        }
 
-        protected void AddILuExpressionConverter<TTypeFrom, TTypeTo, TTypeImpl>(IServiceCollection services)
-            where TTypeImpl : class, ILuExpressionConverter<TTypeFrom, TTypeTo>
-        {
-            services.AddSingleton<ILuExpressionConverter<TTypeFrom, TTypeTo>, TTypeImpl>();
-            services.TryAddSingleton<ILuExpressionConverter<TTypeFrom>, TTypeImpl>();
-        }
-
-        protected IServiceProvider GetServiceProvider()
-        {
-            var services = new ServiceCollection();
-            services.AddSingleton<LuExpressionConverterEnumerable>();
-            AddILuExpressionConverter<TestDbo1, TestModel1, LuDMECTest1>(services);
-            AddILuExpressionConverter<TestDbo2, TestModel2, LuDMECTest2>(services);
-            AddILuExpressionConverter<LuExpressionConverterStaticMethods, LuExpressionConverterStaticMethods, LuExpressionConverterStaticMethods>(services);
-            AddILuExpressionConverter<string, string, LuExpressionConverterIdentity<string>>(services);
-            AddILuExpressionConverter<Guid, Guid, LuExpressionConverterIdentity<Guid>>(services);
-            AddILuExpressionConverter<bool, bool, LuExpressionConverterIdentity<bool>>(services);
-
-            var serviceProvider = services.BuildServiceProvider();
-            return serviceProvider;
-        }
-
-        [Fact]
-        public void Test4()
-        {
-            Expression<Func<TestDbo2, Guid>> expDbo = (x => x.TestDbo1.Id);
-            Expression<Func<TestModel2, Guid>> expModel = (x => x.TestModel1.Id);
-            var options = new LuExpressionConverterOptions
-            {
-                Parameter = Expression.Parameter(typeof(TestModel2), "x")
-            };
-            var converter = new LuExpressionConverterVisitor(options, GetServiceProvider());
-            var result = converter.Visit(expDbo.Body);
-            var lamdba = result != null ? Expression.Lambda<Func<TestModel2, Guid>>(result, options.Parameter) : null;
-            Assert.Equal(expModel.ToString(), lamdba?.ToString());
-        }
-
-        [Fact]
-        public void Test5()
-        {
-            Expression<Func<TestDbo2, int>> expDbo = (x => 0);
-            Expression<Func<TestModel2, int>> expModel = (x => 0);
-            var options = new LuExpressionConverterOptions
-            {
-                Parameter = Expression.Parameter(typeof(TestModel2), "x")
-            };
-            var converter = new LuExpressionConverterVisitor(options, GetServiceProvider());
-            var result = converter.Visit(expDbo.Body);
-            var lamdba = result != null ? Expression.Lambda<Func<TestModel2, int>>(result, options.Parameter) : null;
-            Assert.Equal(expModel.ToString(), lamdba?.ToString());
-        }
-
-        [Fact]
-        public void Test6()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => x.Name.Contains("s"));
-            Expression<Func<TestModel2, bool>> expModel = (x => x.Name.Contains("s"));
-            var options = new LuExpressionConverterOptions
-            {
-                Parameter = Expression.Parameter(typeof(TestModel2), "x")
-            };
-            var converter = new LuExpressionConverterVisitor(options, GetServiceProvider());
-            var result = converter.Visit(expDbo.Body);
-            var lamdba = result != null ? Expression.Lambda<Func<TestModel2, bool>>(result, options.Parameter) : null;
-            Assert.Equal(expModel.ToString(), lamdba?.ToString());
-        }
-
-        [Fact]
-        public void Test7()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Contains("s"));
-            Expression<Func<TestModel2, bool>> expModel = (x => x.TestModel1.Name.Contains("s"));
-            var options = new LuExpressionConverterOptions
-            {
-                Parameter = Expression.Parameter(typeof(TestModel2), "x")
-            };
-            var converter = new LuExpressionConverterVisitor(options, GetServiceProvider());
-            var result = converter.Visit(expDbo.Body);
-            var lamdba = result != null ? Expression.Lambda<Func<TestModel2, bool>>(result, options.Parameter) : null;
-            Assert.Equal(expModel.ToString(), lamdba?.ToString());
-        }
-
-        [Fact]
-        public void Test8()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Contains(x.Name));
-            Expression<Func<TestModel2, bool>> expModel = (x => x.TestModel1.Name.Contains(x.Name));
-            var options = new LuExpressionConverterOptions
-            {
-                Parameter = Expression.Parameter(typeof(TestModel2), "x")
-            };
-            var converter = new LuExpressionConverterVisitor(options, GetServiceProvider());
-            var result = converter.Visit(expDbo.Body);
-            var lamdba = result != null ? Expression.Lambda<Func<TestModel2, bool>>(result, options.Parameter) : null;
-            Assert.Equal(expModel.ToString(), lamdba?.ToString());
-        }
+//        protected void AddILuExpressionConverter<TTypeFrom, TTypeTo, TTypeImpl>(IServiceCollection services)
+//            where TTypeImpl : class, ILuExpressionConverter<TTypeFrom, TTypeTo>
+//        {
+//            services.AddSingleton<ILuExpressionConverter<TTypeFrom, TTypeTo>, TTypeImpl>();
+//            services.TryAddSingleton<ILuExpressionConverter<TTypeFrom>, TTypeImpl>();
+//        }
 
-        [Fact]
-        public void Test9()
-        {
-            Expression<Func<TestDbo1, bool>> expDbo = (x => x.TestDbo2s.Any());
-            Expression<Func<TestModel1, bool>> expModel = (x => x.TestModel2.Any());
-            var options = new LuExpressionConverterOptions
-            {
-                Parameter = Expression.Parameter(typeof(TestModel1), "x")
-            };
-            var converter = new LuExpressionConverterVisitor(options, GetServiceProvider());
-            var result = converter.Visit(expDbo.Body);
-            var lamdba = result != null ? Expression.Lambda<Func<TestModel2, bool>>(result, options.Parameter) : null;
-            Assert.Equal(expModel.ToString(), lamdba?.ToString());
-        }
+//        [Fact]
+//        public void Test()
+//        {
+////            var parentScopeVar = new TestDbo1();
+////            Expression<Func<TestDbo2, Guid>> expDbo = (x => parentScopeVar.Id);
+////            var type = typeof(ILuObjectConverterDescriptor<,>);
+////            var gtype = type.MakeGenericType(typeof(int), typeof(Enumerable));
+//        }
 
-        [Fact]
-        public void Test10()
-        {
-            Expression<Func<TestDbo1, bool>> expDbo = (x => x.TestDbo2s.Any(y => y.Name.Contains(x.Name + "s")));
-            Expression<Func<TestModel1, bool>> expModel = (x => x.TestModel2.Any(y => y.Name.Contains(x.Name + "s")));
-            var options = new LuExpressionConverterOptions
-            {
-                Parameter = Expression.Parameter(typeof(TestModel1), "x")
-            };
-            var converter = new LuExpressionConverterVisitor(options, GetServiceProvider());
-            var result = converter.Visit(expDbo.Body);
-            var lamdba = result != null ? Expression.Lambda<Func<TestModel2, bool>>(result, options.Parameter) : null;
-            Assert.Equal(expModel.ToString(), lamdba?.ToString());
-        }
     }
 }

Luticate2.Auth/Business/Auth/DMEC/LuDMECGroupsToModel.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Business.Fields.DMEC;
-using Luticate2.Auth.DataAccess.Models;
-using Luticate2.Auth.Dbo.Auth;
-using Luticate2.Auth.Dbo.Result;
-
-namespace Luticate2.Auth.Business.Auth.DMEC
-{
-    public class LuDMECGroupsToModel : LuExpressionConverter<LuGroupDbo, LuGroups>
-    {
-        public LuDMECGroupsToModel(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression> ConvertInternal(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            var expression = expressions.Peek();
-            if (expression is MemberExpression memberExpression)
-            {
-                if (MemberMatch(x => x.Id, memberExpression))
-                {
-                    return MakeMemberAccess(x => x.Id, expressions, baseExpression, options);
-                }
-                if (MemberMatch(x => x.Name, memberExpression))
-                {
-                    return MakeMemberAccess(x => x.Name, expressions, baseExpression, options);
-                }
-            }
-
-            return base.ConvertInternal(expressions, baseExpression, options);
-        }
-    }
-}

Luticate2.Auth/Business/Auth/LuGroupsBusiness.cs

@@ -1,14 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Security.Cryptography.X509Certificates;
 using Luticate2.Auth.Business.Crud;
 using Luticate2.Auth.Business.Fields;
 using Luticate2.Auth.DataAccess;
 using Luticate2.Auth.DataAccess.Models;
 using Luticate2.Auth.Dbo.Auth;
 using Luticate2.Auth.Dbo.Fields;
-using Luticate2.Auth.Dbo.Pagination;
 using Luticate2.Auth.Dbo.Result;
 using Microsoft.EntityFrameworkCore;
 

Luticate2.Auth/Business/Auth/PartialObjectCopier/LuPOCGroupsToDbo.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using Luticate2.Auth.Business.PartialObjectCopier;
 using Luticate2.Auth.DataAccess.Models;
 using Luticate2.Auth.Dbo.Auth;

Luticate2.Auth/Business/Crud/LuEfCrudBusiness.cs

@@ -2,8 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Business.Fields.DMEC;
+using Luticate2.Auth.Business.ExpressionConverter;
 using Luticate2.Auth.Dbo;
 using Luticate2.Auth.Dbo.Fields;
 using Luticate2.Auth.Dbo.Pagination;
@@ -81,34 +80,12 @@ namespace Luticate2.Auth.Business.Crud
 
             var options = new LuExpressionConverterOptions
             {
-                Parameter = Expression.Parameter(typeof(TModel), "x")
+                Parameters = new Dictionary<ParameterExpression, Expression>(), // TODO
+                Types = null // TODO
             };
             var converter = new LuExpressionConverterVisitor(options, ServiceProvider);
-            var result = converter.Visit(lamdbaDbo.Body);
-            var lamdbaModel = result != null ? Expression.Lambda<Func<TModel, bool>>(result, options.Parameter) : null;
+            var lamdbaModel = converter.Visit(lamdbaDbo) as Expression<Func<TModel, bool>>;// TODO Handle errors
             return LuResult<IQueryable<TModel>>.Ok(queryable.Where(lamdbaModel));
-
-//            var converter = ServiceProvider.GetService<ILuExpressionConverter<TDbo, TModel>>();
-//            if (converter == null)
-//            {
-//                return LuResult<IQueryable<TModel>>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: ILuDboModelExpressionConverter<{typeof(TModel).Name}, {typeof(TDbo).Name}>");
-//            }
-//
-//            var lamdba = (Expression<Func<TDbo, bool>>) filter.Expression;
-//            var options = new LuDMECOptions
-//            {
-//                Parameter = Expression.Parameter(typeof(TModel), lamdba.Parameters[0].Name)
-//            };
-//            var convertResult = converter.ConvertExpression(lamdba.Body, options);
-//            if (!convertResult)
-//            {
-//                return convertResult.To<IQueryable<TModel>>();
-//            }
-//
-//            var lambdaNoConvert = Expression.Lambda<Func<TModel, bool>>(convertResult.Data, options.Parameter);
-//
-//            return LuResult<IQueryable<TModel>>.Ok(queryable.Where(lambdaNoConvert));
-            return LuResult<IQueryable<TModel>>.Ok(queryable);
         }
 
         protected virtual LuResult<IQueryable<TModel>> OrderByField(LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable)

Luticate2.Auth/Business/ExpressionConverter/LuExpressionConverterOptions.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Luticate2.Auth.Business.ExpressionConverter
+{
+    public class LuExpressionConverterOptions
+    {
+        public IDictionary<ParameterExpression, Expression> Parameters { get; set; }
+
+        public IDictionary<Type, Type> Types { get; set; }
+    }
+}

Luticate2.Auth/Business/ExpressionConverter/LuExpressionConverterVisitor.cs

@@ -0,0 +1,280 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Result;
+using Luticate2.Auth.Exceptions;
+using Luticate2.Auth.Interfaces;
+
+namespace Luticate2.Auth.Business.ExpressionConverter
+{
+    public class LuExpressionConverterVisitor : ExpressionVisitor
+    {
+        public LuExpressionConverterOptions Options { get; }
+
+        protected IServiceProvider ServiceProvider { get; }
+
+        public LuExpressionConverterVisitor(LuExpressionConverterOptions options, IServiceProvider serviceProvider)
+        {
+            Options = options;
+            ServiceProvider = serviceProvider;
+        }
+
+        protected LuResult<Stack<Expression>> StackSimpleExpression(Expression expression, Stack<Expression> stack)
+        {
+            stack.Push(expression);
+            if (expression is MemberExpression memberExpression)
+            {
+                if (memberExpression.Expression != null)
+                {
+                    var result = StackSimpleExpression(memberExpression.Expression, stack);
+                    return result;
+                }
+                return LuResult<Stack<Expression>>.Ok(stack);
+            }
+            else if (expression is MethodCallExpression methodCallExpression)
+            {
+                if (methodCallExpression.Object != null)
+                {
+                    var result = StackSimpleExpression(methodCallExpression.Object, stack);
+                    return result;
+                }
+                return LuResult<Stack<Expression>>.Ok(stack);
+            }
+            else
+            {
+                return LuResult<Stack<Expression>>.Ok(stack);
+            }
+        }
+
+        protected ILuObjectConverterDescriptor GetConverterDescriptor(Type typeFrom, Type typeTo)
+        {
+            var type = typeof(ILuObjectConverterDescriptor<,>);
+            var gtype = type.MakeGenericType(typeFrom, typeTo);
+            var descriptor = (ILuObjectConverterDescriptor) ServiceProvider.GetService(gtype);
+            if (descriptor == null && typeFrom == typeTo)
+            {
+                descriptor = (ILuObjectConverterDescriptor) ServiceProvider.GetService(typeof(ILuObjectConverterDescriptorIdentity));
+            }
+            return descriptor;
+        }
+
+        protected LuResult<Expression> ConvertMemberExpression(MemberExpression memberExpression, Expression newExpression, Type typeTo)
+        {
+            var typeFrom = memberExpression.Expression == null ? memberExpression.Member.DeclaringType : memberExpression.Expression.Type;
+            var descriptor = GetConverterDescriptor(typeFrom, typeTo);
+            if (descriptor == null)
+            {
+                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Could not find converter descriptor for {typeFrom} => {typeTo}");
+            }
+
+            var valueExpression = descriptor.GetMemberValueExpression(memberExpression.Member, Options.Types);
+            if (valueExpression == null)
+            {
+                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Could not find converter descriptor lambda for {typeFrom} => {typeTo} => {memberExpression.Member}");
+            }
+            if (valueExpression.Parameters[0].Type != typeTo)
+            {
+                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Invalid conversion lambda for {typeFrom} => {typeTo}");
+            }
+
+            if (newExpression != null)
+            {
+                Options.Parameters.Add(valueExpression.Parameters[0], newExpression);
+            }
+
+            var visitor = new LuExpressionParamReplaceVisitor(Options);
+            var replacedExpression = visitor.Visit(valueExpression.Body);
+            newExpression = LuExpressionUtils.GetFromConvert(replacedExpression);
+
+            if (newExpression != null)
+            {
+                Options.Parameters.Remove(valueExpression.Parameters[0]);
+            }
+
+            return LuResult<Expression>.Ok(newExpression);
+        }
+
+        protected LuResult<Expression> ConvertMethodCallExpression(MethodCallExpression methodCallExpression, Expression newExpression, Type typeTo)
+        {
+            var typeFrom = methodCallExpression.Object == null ? methodCallExpression.Method.DeclaringType : methodCallExpression.Object.Type;
+            var descriptor = GetConverterDescriptor(typeFrom, typeTo);
+            if (descriptor == null)
+            {
+                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Could not find converter descriptor for {typeFrom} => {typeTo}");
+            }
+
+            var valueExpression = descriptor.GetMethodValueExpression(methodCallExpression.Method, Options.Types);
+            if (valueExpression == null)
+            {
+                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Could not find converter descriptor lambda for {typeFrom} => {typeTo} => {methodCallExpression.Method}");
+            }
+            if (valueExpression.Parameters.Count != methodCallExpression.Arguments.Count + 1)
+            {
+                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Converter descriptor lambda has incorrect number of arguments for {typeFrom} => {typeTo} => {methodCallExpression.Method}");
+            }
+            if (valueExpression.Parameters[0].Type != typeTo)
+            {
+                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Invalid conversion lambda for {typeFrom} => {typeTo}");
+            }
+
+            var visitorConverter = new LuExpressionConverterVisitor(Options, ServiceProvider);
+            for (var i = 0; i < methodCallExpression.Arguments.Count; ++i)
+            {
+                var convertedArgument = visitorConverter.Visit(methodCallExpression.Arguments[i]);
+                Options.Parameters.Add(valueExpression.Parameters[i + 1], convertedArgument);
+            }
+            Options.Parameters.Add(valueExpression.Parameters[0], newExpression);
+            var visitor = new LuExpressionParamReplaceVisitor(Options);
+            var replacedExpression = visitor.Visit(valueExpression.Body);
+            newExpression = LuExpressionUtils.GetFromConvert(replacedExpression);
+            Options.Parameters.Remove(valueExpression.Parameters[0]);
+
+            return LuResult<Expression>.Ok(newExpression);
+        }
+
+        protected LuResult<Expression> ReplaceExpression(Expression expression)
+        {
+            var stackResult = StackSimpleExpression(expression, new Stack<Expression>());
+            if (!stackResult)
+            {
+                return stackResult.To<Expression>();
+            }
+
+            Expression newExpression;
+            var currentExp = stackResult.Data.Pop();
+
+            if (currentExp is ParameterExpression parameterExpression)
+            {
+                if (!Options.Parameters.ContainsKey(parameterExpression))
+                {
+                    return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                        $"Could not find a conversion for parameter {parameterExpression}");
+                }
+                newExpression = Options.Parameters[parameterExpression];
+            }
+            else if (currentExp is MemberExpression memberExpression)
+            {
+                var typeFrom = memberExpression.Member.DeclaringType;
+                var typeTo = Options.Types.ContainsKey(typeFrom) ? Options.Types[typeFrom] : typeFrom;
+
+                var convertResult = ConvertMemberExpression(memberExpression, null, typeTo);
+                if (!convertResult)
+                {
+                    return convertResult;
+                }
+
+                newExpression = convertResult.Data;
+            }
+            else if (currentExp is MethodCallExpression methodCallExpression)
+            {
+                var typeFrom = methodCallExpression.Method.DeclaringType;
+                var typeTo = Options.Types.ContainsKey(typeFrom) ? Options.Types[typeFrom] : typeFrom;
+
+                var convertResult = ConvertMethodCallExpression(methodCallExpression, null, typeTo);
+                if (!convertResult)
+                {
+                    return convertResult;
+                }
+
+                newExpression = convertResult.Data;
+            }
+            else
+            {
+                var visitor = new LuExpressionConverterVisitor(Options, ServiceProvider);
+                newExpression = visitor.Visit(currentExp);
+            }
+
+            if (newExpression == null)
+            {
+                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Invalid simple expression first member: {currentExp}", "");
+            }
+
+            while (stackResult.Data.Any())
+            {
+                currentExp = stackResult.Data.Pop();
+
+                if (currentExp is MemberExpression memberExpression)
+                {
+                    var typeTo = newExpression.Type;
+
+                    var convertResult = ConvertMemberExpression(memberExpression, newExpression, typeTo);
+                    if (!convertResult)
+                    {
+                        return convertResult;
+                    }
+
+                    newExpression = convertResult.Data;
+                }
+                else if (currentExp is MethodCallExpression methodCallExpression)
+                {
+                    var typeTo = newExpression.Type;
+
+                    var convertResult = ConvertMethodCallExpression(methodCallExpression, newExpression, typeTo);
+                    if (!convertResult)
+                    {
+                        return convertResult;
+                    }
+
+                    newExpression = convertResult.Data;
+                }
+                else
+                {
+                    return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                        $"Unknown expression type (should not happen) {currentExp}");
+                }
+            }
+
+            return LuResult<Expression>.Ok(newExpression);
+        }
+
+        protected override Expression VisitMember(MemberExpression node)
+        {
+            return ReplaceExpression(node).ThrowIfNotSuccess().Data;
+        }
+
+        protected override Expression VisitMethodCall(MethodCallExpression node)
+        {
+            return ReplaceExpression(node).ThrowIfNotSuccess().Data;
+        }
+
+        protected override Expression VisitParameter(ParameterExpression node)
+        {
+            if (!Options.Parameters.ContainsKey(node))
+            {
+                LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Could not find a conversion for parameter {node}").Throw();
+            }
+            return Options.Parameters[node];
+        }
+
+        protected override Expression VisitLambda<T>(Expression<T> node)
+        {
+            var convertedParams = new List<ParameterExpression>();
+            foreach (var parameter in node.Parameters)
+            {
+                // TODO check Options.Types[parameter.Type] access
+                var convertedParam = Expression.Parameter(Options.Types[parameter.Type]);
+                Options.Parameters.Add(parameter, convertedParam);
+                convertedParams.Add(convertedParam);
+            }
+            var convertedBody = Visit(node.Body);
+            foreach (var parameter in node.Parameters)
+            {
+                Options.Parameters.Remove(parameter);
+            }
+
+            var convertedLambda = Expression.Lambda(convertedBody, convertedParams);
+            return convertedLambda;
+        }
+    }
+}

Luticate2.Auth/Business/ExpressionConverter/LuExpressionParamReplaceVisitor.cs

@@ -0,0 +1,28 @@
+using System.Linq.Expressions;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Result;
+using Luticate2.Auth.Exceptions;
+
+namespace Luticate2.Auth.Business.ExpressionConverter
+{
+    public class LuExpressionParamReplaceVisitor : ExpressionVisitor
+    {
+        public LuExpressionConverterOptions Options { get; }
+
+        public LuExpressionParamReplaceVisitor(LuExpressionConverterOptions options)
+        {
+            Options = options;
+        }
+
+        protected override Expression VisitParameter(ParameterExpression node)
+        {
+            if (!Options.Parameters.ContainsKey(node))
+            {
+                LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
+                    $"Could not find a conversion for parameter {node}").Throw();
+            }
+
+            return Options.Parameters[node];
+        }
+    }
+}

Luticate2.Auth/Business/Fields/DMEC/LuExpressionConverterEnumerable.cs

@@ -1,58 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using Luticate2.Auth.Dbo;
-using Luticate2.Auth.Dbo.Result;
-using Luticate2.Auth.Interfaces;
-
-namespace Luticate2.Auth.Business.Fields.DMEC
-{
-    public class LuExpressionConverterEnumerable : ILuExpressionConverter
-    {
-        public IServiceProvider ServiceProvider { get; }
-
-        public LuExpressionConverterEnumerable(IServiceProvider serviceProvider)
-        {
-            ServiceProvider = serviceProvider;
-        }
-
-        protected LuResult<Expression> ConvertOther(Type typeFrom, Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            var type = typeof(ILuExpressionConverter<>);
-            var gtype = type.MakeGenericType(typeFrom);
-            var converter = (ILuExpressionConverter) ServiceProvider.GetService(gtype);
-            if (converter == null)
-            {
-                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: {gtype}>");
-            }
-
-            return converter.ConvertExpression(expressions, baseExpression, options);
-        }
-
-        public LuResult<Expression> ConvertExpression(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            if (!expressions.Any())
-            {
-                return LuResult<Expression>.Ok(baseExpression);
-            }
-
-            var expression = expressions.Pop();
-            if (expression is MethodCallExpression methodCallExpression)
-            {
-                var argumentsModel = new List<Expression>();
-                foreach (var argumentDbo in methodCallExpression.Arguments)
-                {
-                    var converter = new LuExpressionConverterVisitor(options, ServiceProvider);
-                    var result = converter.Visit(argumentDbo);
-                    argumentsModel.Add(result);
-                }
-
-                var newExpression = Expression.Call(baseExpression, methodCallExpression.Method, argumentsModel);
-                return ConvertOther(newExpression.Type, expressions, newExpression, options);
-            }
-
-            return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(), "Not supported expression");
-        }
-    }
-}

Luticate2.Auth/Business/Fields/DMEC/LuExpressionConverterIdentity.cs

@@ -1,38 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using Luticate2.Auth.Dbo.Result;
-
-namespace Luticate2.Auth.Business.Fields.DMEC
-{
-    public class LuExpressionConverterIdentity<TType> : LuExpressionConverter<TType, TType>
-    {
-        public LuExpressionConverterIdentity(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression> ConvertInternal(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            var expression = expressions.Pop();
-            if (expression is MemberExpression memberExpression)
-            {
-                var newExpression = Expression.MakeMemberAccess(baseExpression, memberExpression.Member);
-                return ConvertOther(newExpression.Type, expressions, newExpression, options);
-            }
-            else if (expression is MethodCallExpression methodCallExpression)
-            {
-                var argumentsModel = new List<Expression>();
-                foreach (var argumentDbo in methodCallExpression.Arguments)
-                {
-                    var converter = new LuExpressionConverterVisitor(options, ServiceProvider);
-                    var result = converter.Visit(argumentDbo);
-                    argumentsModel.Add(result);
-                }
-
-                var newExpression = Expression.Call(baseExpression, methodCallExpression.Method, argumentsModel);
-                return ConvertOther(newExpression.Type, expressions, newExpression, options);
-            }
-            return base.ConvertInternal(expressions, baseExpression, options);
-        }
-    }
-}

Luticate2.Auth/Business/Fields/DMEC/LuExpressionConverterOptions.cs

@@ -1,9 +0,0 @@
-using System.Linq.Expressions;
-
-namespace Luticate2.Auth.Business.Fields.DMEC
-{
-    public class LuExpressionConverterOptions
-    {
-        public ParameterExpression Parameter { get; set; }
-    }
-}

Luticate2.Auth/Business/Fields/DMEC/LuExpressionConverterStaticMethods.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using Luticate2.Auth.Dbo.Result;
-using Luticate2.Auth.Interfaces;
-
-namespace Luticate2.Auth.Business.Fields.DMEC
-{
-    public class LuExpressionConverterStaticMethods : LuExpressionConverter<LuExpressionConverterStaticMethods, LuExpressionConverterStaticMethods>
-    {
-        public IDictionary<Type, Type> Converters { get; } = new Dictionary<Type, Type>();
-
-        public LuExpressionConverterStaticMethods(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-            Converters.Add(typeof(Enumerable), typeof(LuExpressionConverterEnumerable));
-        }
-
-        protected override LuResult<Expression> ConvertInternal(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            var expression = expressions.Peek();
-            if (expression is MethodCallExpression methodCallExpression)
-            {
-                if (Converters.ContainsKey(methodCallExpression.Method.DeclaringType))
-                {
-                    var type = Converters[methodCallExpression.Method.DeclaringType];
-                    var service = (ILuExpressionConverter) ServiceProvider.GetService(type);
-                    return service.ConvertExpression(expressions, baseExpression, options);
-                }
-            }
-
-            return base.ConvertInternal(expressions, baseExpression, options);
-        }
-    }
-}

Luticate2.Auth/Business/Fields/LuExpressionConverter.cs

@@ -1,96 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields.DMEC;
-using Luticate2.Auth.Dbo;
-using Luticate2.Auth.Dbo.Result;
-using Luticate2.Auth.Interfaces;
-using Microsoft.EntityFrameworkCore.Internal;
-
-namespace Luticate2.Auth.Business.Fields
-{
-    public class LuExpressionConverter<TTypeFrom, TTypeTo> : ILuExpressionConverter<TTypeFrom, TTypeTo>
-    {
-        protected IServiceProvider ServiceProvider { get; }
-
-        public LuExpressionConverter(IServiceProvider serviceProvider)
-        {
-            ServiceProvider = serviceProvider;
-        }
-
-        public virtual LuResult<Expression> ConvertExpression(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            if (!expressions.Any())
-            {
-                return LuResult<Expression>.Ok(baseExpression);
-            }
-
-            var expression = expressions.Peek();
-            if (expression is ParameterExpression parameterExpression)
-            {
-                if (parameterExpression.Type != typeof(TTypeFrom))
-                {
-                    return LuResult<Expression>.Error(LuStatus.InputError.ToInt(), "Bad parameter expression type");
-                }
-
-                expressions.Pop();
-                return ConvertExpression(expressions, options.Parameter, options);
-            }
-            else if (expression is MemberExpression memberExpression)
-            {
-                if (memberExpression.Member.DeclaringType != typeof(TTypeFrom))
-                {
-                    return LuResult<Expression>.Error(LuStatus.InputError.ToInt(), "Bad member expression type");
-                }
-            }
-            else if (expression is MethodCallExpression methodCallExpression)
-            {
-                if (methodCallExpression.Object != null && methodCallExpression.Object.Type != typeof(TTypeFrom))
-                {
-                    return LuResult<Expression>.Error(LuStatus.InputError.ToInt(), "Bad method call expression type");
-                }
-            }
-
-            var convertResult = ConvertInternal(expressions, baseExpression, options);
-            return convertResult;
-        }
-
-        protected LuResult<Expression> ConvertOther(Type typeFrom, Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            var type = typeof(ILuExpressionConverter<>);
-            var gtype = type.MakeGenericType(typeFrom);
-            var converter = (ILuExpressionConverter) ServiceProvider.GetService(gtype);
-            if (converter == null)
-            {
-                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: {gtype}>");
-            }
-
-            return converter.ConvertExpression(expressions, baseExpression, options);
-        }
-
-        protected bool MemberMatch<TTypeFromProperty>(Expression<Func<TTypeFrom, TTypeFromProperty>> member, MemberExpression memberExpression)
-        {
-            return LuExpressionUtils.GetSingleMemberFromExpression(member) == memberExpression.Member;
-        }
-
-        protected LuResult<Expression> MakeMemberAccess<TTypeToProperty>(Expression<Func<TTypeTo, TTypeToProperty>> expression, Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            var exp = expressions.Pop();
-            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression(expression);
-            var newExpression = Expression.MakeMemberAccess(baseExpression, memberInfo);
-            var convertResult = ConvertOther(exp.Type, expressions, newExpression, options);
-            return convertResult;
-        }
-
-//        protected LuResult<Expression> MakeMethodCall<TTypeToProperty>(Expression<Func<TTypeTo, TTypeToProperty>> expression, Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-//        {
-//            var exp = expressions.Pop();
-//        }
-
-        protected virtual LuResult<Expression> ConvertInternal(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
-        {
-            return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(), "Not supported expression");
-        }
-    }
-}

Luticate2.Auth/Business/Fields/LuExpressionConverterVisitor.cs

@@ -1,88 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields.DMEC;
-using Luticate2.Auth.Dbo;
-using Luticate2.Auth.Dbo.Result;
-using Luticate2.Auth.Exceptions;
-using Luticate2.Auth.Interfaces;
-
-namespace Luticate2.Auth.Business.Fields
-{
-    public class LuExpressionConverterVisitor : ExpressionVisitor
-    {
-        public LuExpressionConverterOptions Options { get; }
-
-        protected IServiceProvider ServiceProvider { get; }
-
-        public LuExpressionConverterVisitor(LuExpressionConverterOptions options, IServiceProvider serviceProvider)
-        {
-            Options = options;
-            ServiceProvider = serviceProvider;
-        }
-
-        protected LuResult<Stack<Expression>> StackSimpleExpression(Expression expression, Stack<Expression> stack)
-        {
-            if (expression is ParameterExpression parameterExpression)
-            {
-                stack.Push(parameterExpression);
-                return LuResult<Stack<Expression>>.Ok(stack);
-            }
-            else if (expression is MemberExpression memberExpression)
-            {
-                stack.Push(memberExpression);
-                var result = StackSimpleExpression(memberExpression.Expression, stack);
-                return result;
-            }
-            else if (expression is MethodCallExpression methodCallExpression)
-            {
-                if (methodCallExpression.Object != null)
-                {
-                    stack.Push(methodCallExpression);
-                    var result = StackSimpleExpression(methodCallExpression.Object, stack);
-                    return result;
-                }
-                else
-                {
-                    stack.Push(methodCallExpression);
-                    var param = Expression.Parameter(typeof(LuExpressionConverterStaticMethods));
-                    stack.Push(param);
-                    return LuResult<Stack<Expression>>.Ok(stack);
-                }
-            }
-
-            return LuResult<Stack<Expression>>.Error(LuStatus.InternalError.ToInt(), "Invalid Simple Expression Member");
-        }
-
-        protected Expression ReplaceExpression(Expression expression)
-        {
-            var stackResult = StackSimpleExpression(expression, new Stack<Expression>()).ThrowIfNotSuccess();
-
-            var firstResult = stackResult.Data.Peek();
-
-            var type = typeof(ILuExpressionConverter<>);
-            var gtype = type.MakeGenericType(firstResult.Type);
-            var converter = (ILuExpressionConverter) ServiceProvider.GetService(gtype);
-            if (converter == null)
-            {
-                LuResult<Expression>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: ILuExpressionConverter<{firstResult.Type.Name}>").Throw();
-            }
-
-            var exp = converter.ConvertExpression(stackResult.Data, null, Options).ThrowIfNotSuccess();
-
-            return exp.Data;
-        }
-
-        protected override Expression VisitMember(MemberExpression node)
-        {
-            return ReplaceExpression(node);
-        }
-
-        protected override Expression VisitMethodCall(MethodCallExpression node)
-        {
-            return ReplaceExpression(node);
-        }
-
-
-    }
-}

Luticate2.Auth/Business/Fields/LuFieldsExtensions.cs

@@ -4,7 +4,6 @@ using System.Linq;
 using System.Linq.Expressions;
 using System.Text.RegularExpressions;
 using Luticate2.Auth.Dbo.Fields;
-using Luticate2.Auth.Dbo.Pagination;
 
 namespace Luticate2.Auth.Business.Fields
 {

Luticate2.Auth/Business/LuExpressionUtils.cs

@@ -10,20 +10,25 @@ namespace Luticate2.Auth.Business
 {
     public static class LuExpressionUtils
     {
-        public static Expression GetFromConvert<TType1, TType2>(Expression<Func<TType1, TType2>> exp)
+        public static Expression GetFromConvert(Expression exp)
         {
+            Expression e = exp;
+            if (exp is LambdaExpression lambdaExpression)
+            {
+                e = lambdaExpression.Body;
+            }
+
             Expression operand;
-            if ((exp.Body.NodeType == ExpressionType.Convert ||
-                 exp.Body.NodeType == ExpressionType.ConvertChecked)
-                && exp.Body is UnaryExpression)
+            if ((e.NodeType == ExpressionType.Convert ||
+                 e.NodeType == ExpressionType.ConvertChecked)
+                && e is UnaryExpression)
             {
-                operand = ((UnaryExpression) exp.Body).Operand;
+                operand = ((UnaryExpression) e).Operand;
             }
             else
             {
-                operand = exp.Body;
+                operand = e;
             }
-
             return operand;
         }
 
@@ -81,17 +86,32 @@ namespace Luticate2.Auth.Business
             return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(), "Bad member expression");
         }
 
-        public static MemberInfo GetSingleMemberFromExpression<TTypeTo, TProperty>(Expression<Func<TTypeTo, TProperty>> property)
+        public static MemberInfo GetSingleMemberFromExpression(LambdaExpression property)
         {
             var memberExpression = GetFromConvert(property) as MemberExpression;
 
-            if (memberExpression != null && memberExpression.Expression == property.Parameters.First())
+            if (memberExpression != null &&
+                (memberExpression.Expression == property.Parameters.First() ||
+                 (memberExpression.Expression == null && memberExpression.Member.DeclaringType == property.Parameters.First().Type)))
             {
                 return memberExpression.Member;
             }
             return null;
         }
 
+        public static MethodInfo GetSingleMethodFromExpression(LambdaExpression method)
+        {
+            var methodCallExpression = GetFromConvert(method) as MethodCallExpression;
+
+            // TODO check if something like methodCallExpression.Method.DeclaringType == method.Parameters.First().Type is usefull/required (static/extension methods)
+            if (methodCallExpression != null &&
+                (methodCallExpression.Object == method.Parameters.First() || methodCallExpression.Object == null))
+            {
+                return methodCallExpression.Method;
+            }
+            return null;
+        }
+
         private static bool GetMembersFromExpression<TTypeTo, TProperty>(
             Expression<Func<TTypeTo, TProperty>> property, IList<MemberInfo> memberInfos)
         {

Luticate2.Auth/Business/ObjectConverter/LuObjectConverterDescriptor.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Luticate2.Auth.Interfaces;
+
+namespace Luticate2.Auth.Business.ObjectConverter
+{
+    public class LuObjectConverterDescriptor : ILuObjectConverterDescriptor
+    {
+        protected enum PropertyType
+        {
+            Value,
+            Object
+        }
+
+        protected class LuObjectConverterDescriptorMemberInfo
+        {
+            public LambdaExpression ValueExpression { get; set; }
+
+            public PropertyType PropertyType { get; set; }
+        }
+
+        protected class LuObjectConverterDescriptorMethodInfo
+        {
+            public LambdaExpression ValueExpression { get; set; }
+        }
+
+        protected delegate LuObjectConverterDescriptorMethodInfo DynamicMethodConverter(MethodInfo methodInfo, IDictionary<Type, Type> types);
+
+        private IDictionary<MemberInfo, LuObjectConverterDescriptorMemberInfo> StaticMemberConverters { get; } = new Dictionary<MemberInfo, LuObjectConverterDescriptorMemberInfo>();
+
+        private IDictionary<MethodInfo, LuObjectConverterDescriptorMethodInfo> StaticMethodConverters { get; } = new Dictionary<MethodInfo, LuObjectConverterDescriptorMethodInfo>();
+
+        private IDictionary<MethodInfo, DynamicMethodConverter> DynamicMethodConverters { get; } = new Dictionary<MethodInfo, DynamicMethodConverter>();
+
+        protected void AddMemberConverter(LambdaExpression memberFrom, LambdaExpression valueExpression, PropertyType propertyType)
+        {
+            // TODO: check memberInfo != null
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression(memberFrom);
+            StaticMemberConverters.Add(memberInfo, new LuObjectConverterDescriptorMemberInfo
+            {
+                ValueExpression = valueExpression,
+                PropertyType = propertyType
+            });
+        }
+
+        protected void AddStaticMethodConverter(LambdaExpression methodFrom, LambdaExpression valueExpression)
+        {
+            // TODO: check methodInfo != null
+            var methodInfo = LuExpressionUtils.GetSingleMethodFromExpression(methodFrom);
+            StaticMethodConverters.Add(methodInfo, new LuObjectConverterDescriptorMethodInfo
+            {
+                ValueExpression = valueExpression
+            });
+        }
+
+        protected void AddDynamicMethodConverter(LambdaExpression methodFrom, DynamicMethodConverter converter)
+        {
+            // TODO: check methodInfo != null
+            var methodInfo = LuExpressionUtils.GetSingleMethodFromExpression(methodFrom);
+            var genericMethodInfo = methodInfo.GetGenericMethodDefinition();
+            DynamicMethodConverters.Add(genericMethodInfo, converter);
+        }
+
+        protected void AddDynamicMethodConverterTemplate(LambdaExpression methodFrom)
+        {
+            AddDynamicMethodConverter(methodFrom,
+                (info, types) =>
+                {
+                    var genericMethodInfo = info.GetGenericMethodDefinition();
+                    var templateMethodInfo = genericMethodInfo.MakeGenericMethod(info.GetGenericArguments().Select(x => types[x]).ToArray());
+
+                    var lambdaParams = new List<ParameterExpression>
+                    {
+                        Expression.Parameter(templateMethodInfo.DeclaringType) // TODO what if DeclaringType is static class
+                    };
+                    var methodParams = templateMethodInfo.GetParameters().Select(x => Expression.Parameter(x.ParameterType)).ToList();
+                    lambdaParams.AddRange(methodParams);
+                    var methodCallExpression = Expression.Call(templateMethodInfo.IsStatic ? null : lambdaParams[0], templateMethodInfo, methodParams);
+                    var lambda = Expression.Lambda(methodCallExpression, lambdaParams);
+
+                    return new LuObjectConverterDescriptorMethodInfo
+                    {
+                        ValueExpression = lambda
+                    };
+                }
+            );
+        }
+
+        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, IDictionary<Type, Type> types)
+        {
+            if (StaticMemberConverters.ContainsKey(memberInfo))
+            {
+                return StaticMemberConverters[memberInfo].ValueExpression;
+            }
+
+            return null;
+        }
+
+        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, IDictionary<Type, Type> types)
+        {
+            if (StaticMethodConverters.ContainsKey(methodInfo))
+            {
+                return StaticMethodConverters[methodInfo].ValueExpression;
+            }
+
+            var genericMethodInfo = methodInfo.GetGenericMethodDefinition();
+            if (DynamicMethodConverters.ContainsKey(genericMethodInfo))
+            {
+                var result = DynamicMethodConverters[genericMethodInfo](methodInfo, types);
+                if (result != null)
+                {
+                    return result.ValueExpression;
+                }
+            }
+
+            return null;
+        }
+    }
+
+    public class LuObjectConverterDescriptor<TTypeFrom, TTypeTo> : LuObjectConverterDescriptor, ILuObjectConverterDescriptor<TTypeFrom, TTypeTo>
+    {
+        protected void AddMemberConverter(Expression<Func<TTypeFrom, object>> memberFrom,
+            Expression<Func<TTypeTo, object>> valueExpression, PropertyType propertyType)
+        {
+            AddMemberConverter((LambdaExpression) memberFrom, valueExpression, propertyType);
+        }
+
+        protected void AddNullMemberConverter(Expression<Func<TTypeFrom, object>> memberFrom)
+        {
+            AddMemberConverter(memberFrom, to => default(TTypeTo), PropertyType.Value);
+        }
+    }
+}

Luticate2.Auth/Business/ObjectConverter/LuObjectConverterDescriptorDbSet.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore;
+
+namespace Luticate2.Auth.Business.ObjectConverter
+{
+    public class LuObjectConverterDescriptorDbSet : LuObjectConverterDescriptor
+    {
+        public LuObjectConverterDescriptorDbSet()
+        {
+            AddDynamicMethodConverterTemplate(
+                (Expression<Func<DbSet<object>, Expression<Func<object, bool>>, bool>>)((source, filter) => source.Any(filter)));
+            AddDynamicMethodConverterTemplate(
+                (Expression<Func<DbSet<object>, Expression<Func<object, bool>>, IQueryable<object>>>)((source, filter) => source.Where(filter)));
+        }
+    }
+}

Luticate2.Auth/Business/ObjectConverter/LuObjectConverterDescriptorEnumerable.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Luticate2.Auth.Interfaces;
+
+namespace Luticate2.Auth.Business.ObjectConverter
+{
+    public class LuObjectConverterDescriptorEnumerable : LuObjectConverterDescriptor
+    {
+        public LuObjectConverterDescriptorEnumerable()
+        {
+            AddDynamicMethodConverterTemplate((Expression<Func<IEnumerable<object>, bool>>)(source => source.Any()));
+            AddDynamicMethodConverterTemplate(
+                (Expression<Func<IEnumerable<object>, Func<object, bool>, bool>>)((source, filter) => source.Any(filter)));
+        }
+    }
+}

Luticate2.Auth/Business/ObjectConverter/LuObjectConverterDescriptorIdentity.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Luticate2.Auth.Interfaces;
+
+namespace Luticate2.Auth.Business.ObjectConverter
+{
+    public class LuObjectConverterDescriptorIdentity : ILuObjectConverterDescriptorIdentity
+    {
+        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, IDictionary<Type, Type> types)
+        {
+            var isStatic = false;
+            if (memberInfo is FieldInfo fieldInfo)
+            {
+                isStatic = fieldInfo.IsStatic;
+            }
+            else if (memberInfo is PropertyInfo propertyInfo)
+            {
+                isStatic = propertyInfo.GetAccessors(true)[0].IsStatic;
+            }
+            var param = Expression.Parameter(memberInfo.DeclaringType);
+            var memberExpression = Expression.MakeMemberAccess(isStatic ? null : param, memberInfo);
+            var lambda = Expression.Lambda(memberExpression, param);
+            return lambda;
+        }
+
+        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, IDictionary<Type, Type> types)
+        {
+            var lambdaParams = new List<ParameterExpression>
+            {
+                Expression.Parameter(methodInfo.DeclaringType) // TODO what if DeclaringType is static class
+            };
+            var methodParams = methodInfo.GetParameters().Select(x => Expression.Parameter(x.ParameterType)).ToList();
+            lambdaParams.AddRange(methodParams);
+            var methodCallExpression = Expression.Call(methodInfo.IsStatic ? null : lambdaParams[0], methodInfo, methodParams);
+            var lambda = Expression.Lambda(methodCallExpression, lambdaParams);
+            return lambda;
+        }
+    }
+}

Luticate2.Auth/DataAccess/Models/LuGroupsObjects.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 
 namespace Luticate2.Auth.DataAccess.Models
 {

Luticate2.Auth/DataAccess/Models/LuUsers.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 
 namespace Luticate2.Auth.DataAccess.Models
 {

Luticate2.Auth/DataAccess/Models/TestTable.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 
 namespace Luticate2.Auth.DataAccess.Models
 {

Luticate2.Auth/DataAccess/Models/luticate2Context.cs

@@ -1,6 +1,4 @@
-using System;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore;
 
 namespace Luticate2.Auth.DataAccess.Models
 {

Luticate2.Auth/Interfaces/ILuExpressionConverter.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields.DMEC;
+using Luticate2.Auth.Business.ExpressionConverter;
 using Luticate2.Auth.Dbo.Result;
 
 namespace Luticate2.Auth.Interfaces

Luticate2.Auth/Interfaces/ILuObjectConverterDescriptor.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Luticate2.Auth.Interfaces
+{
+    public interface ILuObjectConverterDescriptor
+    {
+        LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, IDictionary<Type, Type> types);
+
+        LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, IDictionary<Type, Type> types);
+    }
+
+    public interface ILuObjectConverterDescriptor<TTypeFrom, TTypeTo> : ILuObjectConverterDescriptor
+    {
+    }
+
+    public interface ILuObjectConverterDescriptorIdentity : ILuObjectConverterDescriptor
+    {
+    }
+}