test

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

@@ -1,7 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ContentModelStore">
-    <e p="$USER_HOME$/.Rider2018.1/system/resharper-host/local/Transient/ReSharperHost/v12/SolutionCaches/_luticate2.1484521948.00" t="ExcludeRecursive" />
+    <e p="$APPLICATION_CONFIG_DIR$/consoles/db" t="IncludeRecursive" />
+    <e p="$APPLICATION_CONFIG_DIR$/extensions" t="IncludeRecursive" />
+    <e p="$USER_HOME$/.Rider2018.2/system/extResources" t="IncludeRecursive" />
+    <e p="$USER_HOME$/.Rider2018.2/system/resharper-host/local/Transient/ReSharperHost/v182/SolutionCaches/_luticate2.1484521948.00" t="ExcludeRecursive" />
     <e p="$USER_HOME$/.nuget/packages/xunit.runner.visualstudio/2.3.1/build/netcoreapp1.0/xunit.runner.reporters.netcoreapp10.dll" t="Include" />
     <e p="$USER_HOME$/.nuget/packages/xunit.runner.visualstudio/2.3.1/build/netcoreapp1.0/xunit.runner.utility.netcoreapp10.dll" t="Include" />
     <e p="$USER_HOME$/.nuget/packages/xunit.runner.visualstudio/2.3.1/build/netcoreapp1.0/xunit.runner.visualstudio.dotnetcore.testadapter.dll" t="Include" />
@@ -10,9 +13,8 @@
       <e p="Luticate2.Auth" t="IncludeRecursive">
         <e p="Business" t="Include">
           <e p="Auth" t="Include">
-            <e p="FieldsExpressions" t="Include">
-              <e p="LuFieldsExpressionsLuGroupDboLuGroups.cs" t="Include" />
-              <e p="LuFieldsExpressionsLuMetadataDboLuMetadata.cs" 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">
@@ -25,15 +27,17 @@
             <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="LuExpressionConverterVisitor.cs" t="Include" />
             <e p="LuFieldsExtensions.cs" t="Include" />
             <e p="LuPartialFieldsParser.cs" t="Include" />
           </e>
-          <e p="FieldsExpressions" t="Include">
-            <e p="Basic" t="Include">
-              <e p="LuFieldsExpressionsString.cs" t="Include" />
-            </e>
-            <e p="LuFieldsExpressions.cs" t="Include" />
-          </e>
           <e p="LuExpressionUtils.cs" t="Include" />
           <e p="Pagination" t="Include">
             <e p="LuFilterParser.cs" t="Include" />
@@ -94,7 +98,7 @@
         </e>
         <e p="Interfaces" t="Include">
           <e p="ILuCrud.cs" t="Include" />
-          <e p="ILuFieldsExpressions.cs" t="Include" />
+          <e p="ILuExpressionConverter.cs" t="Include" />
           <e p="ILuOrderByObjectType.cs" t="Include" />
           <e p="ILuPartialObjectCopier.cs" t="Include" />
         </e>
@@ -128,11 +132,9 @@
       <e p="Luticate2.Auth.Tests" t="IncludeRecursive">
         <e p="Business" t="Include">
           <e p="Fields" t="Include">
+            <e p="LuDboModelExpressionConverterTests.cs" t="Include" />
             <e p="LuFieldDboTests.cs" t="Include" />
           </e>
-          <e p="FieldsExpressions" t="Include">
-            <e p="LuFieldsExpressionsTests.cs" t="Include" />
-          </e>
           <e p="LuExpressionUtilsTests.cs" t="Include" />
           <e p="Pagination" t="Include">
             <e p="LuFilterTests.cs" t="Include" />

.idea/.idea.luticate2/.idea/indexLayout.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ContentModelUserStore">
+    <attachedFolders />
     <explicitIncludes />
     <explicitExcludes />
   </component>

.idea/httpRequests/2018-07-16T013928.404.html

@@ -0,0 +1,12 @@
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
+<html>
+<head>
+    <title>404 Not Found</title>
+</head>
+<body>
+<h1>Not Found</h1>
+<p>The requested URL /api/item was not found on this server.</p>
+<hr>
+<address>Apache/2.4.29 (Ubuntu) Server at localhost Port 80</address>
+</body>
+</html>

.idea/httpRequests/http-requests-log.http

@@ -0,0 +1,7 @@
+GET http://localhost:80/api/item
+Accept: application/json
+
+<> 2018-07-16T013928.404.html
+
+###
+

Luticate2.Auth.ConsoleSample/Commands/ListCommand.cs

@@ -54,7 +54,7 @@ namespace Luticate2.Auth.ConsoleSample.Commands
                 }
                 var partialResponse = partialResponseResult.Data;
 
-                var filterResult = LuFilterParser.Parse<LuGroups>(Filter);
+                var filterResult = LuFilterParser.Parse<LuGroupDbo>(Filter);
                 if (!filterResult)
                 {
                     filterResult.WriteLineError();

Luticate2.Auth.ConsoleSample/Program.cs

@@ -1,12 +1,9 @@
 using System;
+using System.Collections.Generic;
 using Luticate2.Auth.Business.Auth;
-using Luticate2.Auth.Business.Auth.FieldsExpressions;
+using Luticate2.Auth.Business.Auth.DMEC;
 using Luticate2.Auth.Business.Auth.PartialObjectCopier;
-using Luticate2.Auth.Business.FieldsExpressions;
-using Luticate2.Auth.Business.FieldsExpressions.Basic;
-//using Luticate2.Auth.Business.Pagination.OrderBy;
-//using Luticate2.Auth.Business.Pagination.OrderBy.Basic;
-using Luticate2.Auth.Business.PartialObjectCopier;
+using Luticate2.Auth.Business.Fields.DMEC;
 using Luticate2.Auth.ConsoleSample.Commands;
 using Luticate2.Auth.DataAccess;
 using Luticate2.Auth.DataAccess.Models;
@@ -14,6 +11,7 @@ using Luticate2.Auth.Dbo.Auth;
 using Luticate2.Auth.Interfaces;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using NClap.Metadata;
 using NClap.Repl;
 
@@ -34,6 +32,13 @@ namespace Luticate2.Auth.ConsoleSample
     class Program
     {
         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>();
+        }
         
         static void Main(string[] args)
         {
@@ -46,22 +51,29 @@ namespace Luticate2.Auth.ConsoleSample
             services.AddSingleton<ILuPartialObjectCopier<LuGroupDbo, LuGroups>, LuPOCGroupsToModel>();
 
 
-            services.AddSingleton<ILuFieldsExpressions<LuObjectsMetadataDbo, LuObjectsMetadata>, LuFieldsExpressionsLuMetadataDboLuMetadata>();
-            services.AddSingleton<ILuFieldsExpressions<LuGroupDbo, LuGroups>, LuFieldsExpressionsLuGroupDboLuGroups>();
-
-            services.AddSingleton<ILuFieldsExpressions<string, string>, LuFieldsExpressionsString>();
-            services.AddSingleton<ILuFieldsExpressions<int, int>, LuFieldsExpressions<int, int>>();
-            services.AddSingleton<ILuFieldsExpressions<Guid, Guid>, LuFieldsExpressions<Guid, Guid>>();
+//            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);
 
-            services.AddSingleton<ILuFieldsExpressions<DateTime, DateTime>, LuFieldsExpressions<DateTime, DateTime>>();
-            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset, DateTimeOffset>, LuFieldsExpressions<DateTimeOffset, DateTimeOffset>>();
-            services.AddSingleton<ILuFieldsExpressions<DateTime, DateTimeOffset>, LuFieldsExpressions<DateTime, DateTimeOffset>>();
-            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset, DateTime>, LuFieldsExpressions<DateTimeOffset, DateTime>>();
 
-            services.AddSingleton<ILuFieldsExpressions<DateTime?, DateTime?>, LuFieldsExpressions<DateTime?, DateTime?>>();
-            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset?, DateTimeOffset?>, LuFieldsExpressions<DateTimeOffset?, DateTimeOffset?>>();
-            services.AddSingleton<ILuFieldsExpressions<DateTime?, DateTimeOffset?>, LuFieldsExpressions<DateTime?, DateTimeOffset?>>();
-            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset?, DateTime?>, LuFieldsExpressions<DateTimeOffset?, DateTime?>>();
+//            services.AddSingleton<ILuFieldsExpressions<LuObjectsMetadataDbo, LuObjectsMetadata>, LuFieldsExpressionsLuMetadataDboLuMetadata>();
+//            services.AddSingleton<ILuFieldsExpressions<LuGroupDbo, LuGroups>, LuFieldsExpressionsLuGroupDboLuGroups>();
+//
+//            services.AddSingleton<ILuFieldsExpressions<string, string>, LuFieldsExpressionsString>();
+//            services.AddSingleton<ILuFieldsExpressions<int, int>, LuFieldsExpressions<int, int>>();
+//            services.AddSingleton<ILuFieldsExpressions<Guid, Guid>, LuFieldsExpressions<Guid, Guid>>();
+//
+//            services.AddSingleton<ILuFieldsExpressions<DateTime, DateTime>, LuFieldsExpressions<DateTime, DateTime>>();
+//            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset, DateTimeOffset>, LuFieldsExpressions<DateTimeOffset, DateTimeOffset>>();
+//            services.AddSingleton<ILuFieldsExpressions<DateTime, DateTimeOffset>, LuFieldsExpressions<DateTime, DateTimeOffset>>();
+//            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset, DateTime>, LuFieldsExpressions<DateTimeOffset, DateTime>>();
+//
+//            services.AddSingleton<ILuFieldsExpressions<DateTime?, DateTime?>, LuFieldsExpressions<DateTime?, DateTime?>>();
+//            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset?, DateTimeOffset?>, LuFieldsExpressions<DateTimeOffset?, DateTimeOffset?>>();
+//            services.AddSingleton<ILuFieldsExpressions<DateTime?, DateTimeOffset?>, LuFieldsExpressions<DateTime?, DateTimeOffset?>>();
+//            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset?, DateTime?>, LuFieldsExpressions<DateTimeOffset?, DateTime?>>();
 
             services.AddDbContext<Luticate2DbContext>(options =>
             {

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

@@ -0,0 +1,191 @@
+using System;
+using System.Collections.Generic;
+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.Dbo;
+using Luticate2.Auth.Dbo.Result;
+using Luticate2.Auth.Interfaces;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Luticate2.Auth.Tests.Business.Fields
+{
+    public class TestDbo1
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+
+        public IList<TestDbo2> TestDbo2s { get; set; }
+    }
+
+    public class TestDbo2
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+
+        public TestDbo1 TestDbo1 { get; set; }
+    }
+
+    public class TestModel1
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+
+        public ICollection<TestModel2> TestModel2 { get; set; }
+    }
+
+    public class TestModel2
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+
+        public Guid TestModel1Id { get; set; }
+
+        public TestModel1 TestModel1 { get; set; }
+    }
+
+    public class LuDMECTest1 : LuExpressionConverter<TestDbo1, TestModel1>
+    {
+        public LuDMECTest1(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);
+                }
+                if (MemberMatch(x => x.TestDbo2s, memberExpression))
+                {
+                    return MakeMemberAccess(x => x.TestModel2, expressions, baseExpression, options);
+                }
+            }
+
+            return base.ConvertInternal(expressions, baseExpression, options);
+        }
+    }
+
+    public class LuDMECTest2 : LuExpressionConverter<TestDbo2, TestModel2>
+    {
+        public LuDMECTest2(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);
+                }
+                if (MemberMatch(x => x.TestDbo1, memberExpression))
+                {
+                    return MakeMemberAccess(x => x.TestModel1, expressions, baseExpression, options);
+                }
+            }
+
+            return base.ConvertInternal(expressions, baseExpression, options);
+        }
+    }
+
+    public class LuDboModelExpressionConverterTests
+    {
+        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>>();
+
+            var serviceProvider = services.BuildServiceProvider();
+            return serviceProvider;
+        }
+
+//        [Fact]
+//        public void Test0()
+//        {
+//            var serviceProvider = GetServiceProvider();
+//            var converter = serviceProvider.GetService<ILuDboModelExpressionConverter<TestDbo1, TestModel1>>();
+//            Expression<Func<TestDbo1, TestDbo1>> expDbo = (x => x);
+//            Expression<Func<TestModel1, object>> expModel = (x => (object) x);
+//            var convertResult = converter.ConvertLamdba(expDbo);
+//            Assert.Equal(LuStatus.Success.ToInt(), convertResult.Status);
+//            Assert.NotNull(convertResult.Data);
+//            Assert.Equal(expModel.ToString(), convertResult.Data.ToString());
+//        }
+//
+//        [Fact]
+//        public void Test1()
+//        {
+//            var serviceProvider = GetServiceProvider();
+//            var converter = serviceProvider.GetService<ILuDboModelExpressionConverter<TestDbo1, TestModel1>>();
+//            Expression<Func<TestDbo1, Guid>> expDbo = (x => x.Id);
+//            Expression<Func<TestModel1, object>> expModel = (x => (object) x.Id);
+//            var convertResult = converter.ConvertLamdba(expDbo);
+//            Assert.Equal(LuStatus.Success.ToInt(), convertResult.Status);
+//            Assert.NotNull(convertResult.Data);
+//            Assert.Equal(expModel.ToString(), convertResult.Data.ToString());
+//        }
+//
+//        [Fact]
+//        public void Test2()
+//        {
+//            var serviceProvider = GetServiceProvider();
+//            var converter = serviceProvider.GetService<ILuDboModelExpressionConverter<TestDbo2, TestModel2>>();
+//            Expression<Func<TestDbo2, Guid>> expDbo = (x => x.TestDbo1.Id);
+//            Expression<Func<TestModel2, object>> expModel = (x => (object) x.TestModel1.Id);
+//            var convertResult = converter.ConvertLamdba(expDbo);
+//            Assert.Equal(LuStatus.Success.ToInt(), convertResult.Status);
+//            Assert.NotNull(convertResult.Data);
+//            Assert.Equal(expModel.ToString(), convertResult.Data.ToString());
+//        }
+//
+//        [Fact]
+//        public void Test3()
+//        {
+//            var serviceProvider = GetServiceProvider();
+//            var converter = serviceProvider.GetService<ILuDboModelExpressionConverter<TestDbo2, TestModel2>>();
+//            Expression<Func<TestDbo2, int>> expDbo = (x => x.TestDbo1.Name.Length);
+//            Expression<Func<TestModel2, object>> expModel = (x => (object) x.TestModel1.Name.Length);
+//            var convertResult = converter.ConvertLamdba(expDbo);
+//            Assert.Equal(LuStatus.Success.ToInt(), convertResult.Status);
+//            Assert.NotNull(convertResult.Data);
+//            Assert.Equal(expModel.ToString(), convertResult.Data.ToString());
+//        }
+//
+//        [Fact]
+//        public void Test4()
+//        {
+//            var serviceProvider = GetServiceProvider();
+//            var converter = serviceProvider.GetService<ILuDboModelExpressionConverter<TestDbo2, TestModel2>>();
+//            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Length == 0 || x.Name.Length != 0);
+//            Expression<Func<TestModel2, object>> expModel = (x => (object) (x.TestModel1.Name.Length == 0 || x.Name.Length != 0));
+//            var convertResult = converter.ConvertLamdba(expDbo);
+//            Assert.Equal(LuStatus.Success.ToInt(), convertResult.Status);
+//            Assert.NotNull(convertResult.Data);
+//            Assert.Equal(expModel.ToString(), convertResult.Data.ToString());
+//        }
+    }
+}

Luticate2.Auth.Tests/Business/FieldsExpressions/LuFieldsExpressionsTests.cs

@@ -1,135 +0,0 @@
-using System;
-using System.Linq.Expressions;
-using Luticate2.Auth.Business;
-using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Business.FieldsExpressions;
-using Luticate2.Auth.Business.FieldsExpressions.Basic;
-using Luticate2.Auth.Dbo;
-using Luticate2.Auth.Dbo.Fields;
-using Luticate2.Auth.Dbo.Result;
-using Luticate2.Auth.Interfaces;
-using Microsoft.Extensions.DependencyInjection;
-using Xunit;
-
-namespace Luticate2.Auth.Tests.Business.FieldsExpressions
-{
-    public class LuFieldsExpressionsTestDbo1TestModel1 : LuFieldsExpressions<TestDbo1, TestModel1>
-    {
-        public LuFieldsExpressionsTestDbo1TestModel1(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, TestModel1>> modelProperty, LuFieldDbo field)
-        {
-            if (field.StartsWith<TestDbo1>(x => x.MyInt))
-            {
-                return GetSubField<TType1, int, int>(modelProperty, field, x => x.MyInt);
-            }
-            else if (field.StartsWith<TestDbo1>(x => x.Metadata))
-            {
-                return GetSubField<TType1, MetadataDbo, MetadataModel>(modelProperty, field, x => x.MetadataModel);
-            }
-
-            return base.GetExpressionInternal(modelProperty, field);
-        }
-    }
-
-    public class LuFieldsExpressionsMetadataDboMetadataModel : LuFieldsExpressions<MetadataDbo, MetadataModel>
-    {
-        public LuFieldsExpressionsMetadataDboMetadataModel(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, MetadataModel>> modelProperty, LuFieldDbo field)
-        {
-            if (field.StartsWith<MetadataDbo>(x => x.Id))
-            {
-                return GetSubField<TType1, Guid, Guid>(modelProperty, field, x => x.Id);
-            }
-
-            return base.GetExpressionInternal(modelProperty, field);
-        }
-    }
-    
-    public class TestDbo1
-    {
-        public string MyString { get; set; }
-
-        public int MyInt { get; set; }
-
-        public MetadataDbo Metadata { get; set; }
-    }
-
-    public class MetadataDbo
-    {
-        public Guid Id { get; set; }
-
-        public DateTime CreatedAt { get; set; }
-    }
-    
-    public class TestModel1
-    {
-        public string MyString { get; set; }
-
-        public int MyInt { get; set; }
-
-        public MetadataModel MetadataModel { get; set; }
-    }
-
-    public class MetadataModel
-    {
-        public Guid Id { get; set; }
-
-        public DateTime CreatedAt { get; set; }
-    }
-    
-    public class LuFieldsExpressionsTests
-    {
-        public IServiceProvider GetServiceProvider()
-        {
-            var serviceCollection = new ServiceCollection();
-
-            serviceCollection.AddSingleton<ILuFieldsExpressions<TestDbo1, TestModel1>, LuFieldsExpressionsTestDbo1TestModel1>();
-            serviceCollection.AddSingleton<ILuFieldsExpressions<MetadataDbo, MetadataModel>, LuFieldsExpressionsMetadataDboMetadataModel>();
-            serviceCollection.AddSingleton<ILuFieldsExpressions<string, string>, LuFieldsExpressionsString>();
-            serviceCollection.AddSingleton<ILuFieldsExpressions<int, int>, LuFieldsExpressions<int, int>>();
-            serviceCollection.AddSingleton<ILuFieldsExpressions<Guid, Guid>, LuFieldsExpressions<Guid, Guid>>();
-
-            var serviceProvider = serviceCollection.BuildServiceProvider();
-            return serviceProvider;
-        }
-        
-        [Fact]
-        public void Test1()
-        {
-            var serviceProvider = GetServiceProvider();
-            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
-            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.Id"));
-            Assert.Equal(LuStatus.Success.ToInt(), exprResult.Status);
-            Assert.NotNull(exprResult.Data);
-            var operand = LuExpressionUtils.GetFromConvert(exprResult.Data);
-            var str = operand.ToString();
-            Assert.Equal("x.MetadataModel.Id", str);
-        }
-
-        [Fact]
-        public void TestError1()
-        {
-            var serviceProvider = GetServiceProvider();
-            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
-            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.Id.NxField"));
-            Assert.Equal(LuStatus.InputError.ToInt(), exprResult.Status);
-            Assert.Null(exprResult.Data);
-        }
-
-        [Fact]
-        public void TestError2()
-        {
-            var serviceProvider = GetServiceProvider();
-            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
-            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.*"));
-            Assert.Equal(LuStatus.InputError.ToInt(), exprResult.Status);
-            Assert.Null(exprResult.Data);
-        }
-    }
-}

Luticate2.Auth.Tests/RandomTests.cs

@@ -1,41 +1,174 @@
-using System.Linq;
-using Luticate2.Auth.DataAccess;
-using Luticate2.Auth.DataAccess.Models;
-using Microsoft.EntityFrameworkCore;
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Business.Fields.DMEC;
+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
 {
     public class RandomTests
     {
+
+//        [Fact]
+//        public void Test1()
+//        {
+//            var dbContext = new luticate2Context();
+//            var items = dbContext.LuGroups.Where(groups => groups.LuGroupsObjects.Any(x => x.Priority == 0));
+//            var list = items.ToList();
+//            Assert.NotNull(list);
+//            Assert.Equal(1, list.Count);
+//        }
+//
+//        [Fact]
+//        public void Test2()
+//        {
+//            var dbContext = new luticate2Context();
+//            var items = dbContext.LuGroups.OrderBy(x => x.Id).Where(groups => groups.LuGroupsObjects.Any(x => x.Priority == 0));
+//            var list = items.ToList();
+//            Assert.NotNull(list);
+//            Assert.Equal(1, list.Count);
+//        }
+//
+//        [Fact]
+//        public void Test3()
+//        {
+//            var dbContext = new luticate2Context();
+//            var items = dbContext.LuGroups.OrderBy(x => x.Id);
+//            var list = items.ToList();
+//            Assert.NotNull(list);
+//            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 Test1()
+        public void Test8()
         {
-            var dbContext = new luticate2Context();
-            var items = dbContext.LuGroups.Where(groups => groups.LuGroupsObjects.Any(x => x.Priority == 0));
-            var list = items.ToList();
-            Assert.NotNull(list);
-            Assert.Equal(1, list.Count);
+            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());
         }
 
         [Fact]
-        public void Test2()
+        public void Test9()
         {
-            var dbContext = new luticate2Context();
-            var items = dbContext.LuGroups.OrderBy(x => x.Id).Where(groups => groups.LuGroupsObjects.Any(x => x.Priority == 0));
-            var list = items.ToList();
-            Assert.NotNull(list);
-            Assert.Equal(1, list.Count);
+            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 Test3()
+        public void Test10()
         {
-            var dbContext = new luticate2Context();
-            var items = dbContext.LuGroups.OrderBy(x => x.Id);
-            var list = items.ToList();
-            Assert.NotNull(list);
-            Assert.Equal(2, list.Count);
+            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

@@ -0,0 +1,36 @@
+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/FieldsExpressions/LuFieldsExpressionsLuGroupDboLuGroups.cs

@@ -1,37 +0,0 @@
-using System;
-using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Business.FieldsExpressions;
-using Luticate2.Auth.DataAccess.Models;
-using Luticate2.Auth.Dbo.Auth;
-using Luticate2.Auth.Dbo.Fields;
-using Luticate2.Auth.Dbo.Result;
-
-namespace Luticate2.Auth.Business.Auth.FieldsExpressions
-{
-    public class LuFieldsExpressionsLuGroupDboLuGroups : LuFieldsExpressions<LuGroupDbo, LuGroups>
-    {
-        public LuFieldsExpressionsLuGroupDboLuGroups(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(
-            Expression<Func<TType1, LuGroups>> modelProperty, LuFieldDbo field)
-        {
-            if (field.StartsWith<LuGroupDbo>(x => x.Id))
-            {
-                return GetSubField<TType1, Guid, Guid>(modelProperty, field, x => x.Id);
-            }
-            else if (field.StartsWith<LuGroupDbo>(x => x.Name))
-            {
-                return GetSubField<TType1, string, string>(modelProperty, field, x => x.Name);
-            }
-            else if (field.StartsWith<LuGroupDbo>(x => x.Metadata))
-            {
-                return GetSubField<TType1, LuObjectsMetadataDbo, LuObjectsMetadata>(modelProperty, field, x => x.IdNavigation);
-            }
-
-            return base.GetExpressionInternal(modelProperty, field);
-        }
-    }
-}

Luticate2.Auth/Business/Auth/FieldsExpressions/LuFieldsExpressionsLuMetadataDboLuMetadata.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Business.FieldsExpressions;
-using Luticate2.Auth.DataAccess.Models;
-using Luticate2.Auth.Dbo.Auth;
-using Luticate2.Auth.Dbo.Fields;
-using Luticate2.Auth.Dbo.Result;
-
-namespace Luticate2.Auth.Business.Auth.FieldsExpressions
-{
-    public class LuFieldsExpressionsLuMetadataDboLuMetadata : LuFieldsExpressions<LuObjectsMetadataDbo, LuObjectsMetadata>
-    {
-        public LuFieldsExpressionsLuMetadataDboLuMetadata(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, LuObjectsMetadata>> modelProperty, LuFieldDbo field)
-        {
-            if (field.StartsWith<LuObjectsMetadataDbo>(x => x.Id))
-            {
-                return GetSubField<TType1, Guid, Guid>(modelProperty, field, x => x.Id);
-            }
-            if (field.StartsWith<LuObjectsMetadataDbo>(x => x.CreatedAt))
-            {
-                return GetSubField<TType1, DateTime, DateTimeOffset>(modelProperty, field, x => x.CreatedAt);
-            }
-            if (field.StartsWith<LuObjectsMetadataDbo>(x => x.UpdatedAt))
-            {
-                return GetSubField<TType1, DateTime?, DateTimeOffset?>(modelProperty, field, x => x.UpdatedAt);
-            }
-
-            return base.GetExpressionInternal(modelProperty, field);
-        }
-    }
-}

Luticate2.Auth/Business/Crud/LuEfCrudBusiness.cs

@@ -2,6 +2,8 @@
 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.Dbo;
 using Luticate2.Auth.Dbo.Fields;
 using Luticate2.Auth.Dbo.Pagination;
@@ -75,58 +77,56 @@ namespace Luticate2.Auth.Business.Crud
 
         protected virtual LuResult<IQueryable<TModel>> Filter(LuFilterDbo filter, IQueryable<TModel> queryable)
         {
-            return LuResult<IQueryable<TModel>>.Ok(queryable.Where((Expression<Func<TModel, bool>>) filter.Expression));
-        }
+            var lamdbaDbo = (Expression<Func<TDbo, bool>>) filter.Expression;
 
-        protected IQueryable<TModel> ConvertAndOrderByQueryable<T>(Expression<Func<TModel, object>> exp,
-            LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable, Expression expressionNoConvert)
-        {
-            var ordered = queryable as IOrderedQueryable<TModel>;
-            var expType = expressionNoConvert.Type;
-            var type = typeof(T);
-            if (type.IsAssignableFrom(expType))
+            var options = new LuExpressionConverterOptions
             {
-                var expLambda = Expression.Lambda<Func<TModel, T>>(expressionNoConvert, exp.Parameters);
-                if (ordered != null)
-                {
-                    ordered = orderByfield.Asc ? ordered.ThenBy(expLambda) : ordered.ThenByDescending(expLambda);
-                }
-                else
-                {
-                    ordered = orderByfield.Asc ? queryable.OrderBy(expLambda) : queryable.OrderByDescending(expLambda);
-                }
-            }
-
-            return ordered ?? queryable;
+                Parameter = Expression.Parameter(typeof(TModel), "x")
+            };
+            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;
+            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)
         {
-            var expressionBuilder = ServiceProvider.GetService<ILuFieldsExpressions<TDbo, TModel>>();
-            var expressionResult = expressionBuilder.GetExpression<TModel>(x => x, orderByfield.Field);
-            if (!expressionResult)
-            {
-                return expressionResult.To<IQueryable<TModel>>();
-            }
-
-            var expression = expressionResult.Data;
-            var expressionNoConvert = LuExpressionUtils.GetFromConvert(expression);
-
-            var ordered = ConvertAndOrderByQueryable<bool>(expression, orderByfield, queryable, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<byte>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<DateTime>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<DateTimeOffset>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<decimal>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<double>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<float>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<Guid>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<short>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<int>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<long>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<char>(expression, orderByfield, ordered, expressionNoConvert);
-            ordered = ConvertAndOrderByQueryable<string>(expression, orderByfield, ordered, expressionNoConvert);
-            
-            return LuResult<IQueryable<TModel>>.Ok(ordered);
+//            var expressionBuilder = ServiceProvider.GetService<ILuDboModelExpressionConverter<TDbo, TModel>>();
+//            var expressionResult = expressionBuilder.ConvertLamdba<TModel>(orderByfield.);
+//            if (!expressionResult)
+//            {
+//                return expressionResult.To<IQueryable<TModel>>();
+//            }
+//
+//            var expression = expressionResult.Data;
+//            var expressionNoConvert = LuExpressionUtils.GetFromConvert(expression);
+//
+//            var ordered = queryable.OrderBy(expressionNoConvert);
+//
+//            return LuResult<IQueryable<TModel>>.Ok(ordered);
+            return LuResult<IQueryable<TModel>>.Ok(queryable);
         }
 
         protected virtual LuResult<IQueryable<TModel>> OrderBy(LuOrderByDbo orderBy, IQueryable<TModel> queryable)

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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,88 @@
+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/FieldsExpressions/Basic/LuFieldsExpressionsString.cs

@@ -1,24 +0,0 @@
-using System;
-using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Dbo.Fields;
-using Luticate2.Auth.Dbo.Result;
-
-namespace Luticate2.Auth.Business.FieldsExpressions.Basic
-{
-    public class LuFieldsExpressionsString : LuFieldsExpressions<string, string>
-    {
-        public LuFieldsExpressionsString(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, string>> modelProperty, LuFieldDbo field)
-        {
-            if (field.StartsWith<string>(x => x.Length))
-            {
-                return GetSubField<TType1, int, int>(modelProperty, field, x => x.Length);
-            }
-            return base.GetExpressionInternal(modelProperty, field);
-        }
-    }
-}

Luticate2.Auth/Business/FieldsExpressions/LuFieldsExpressions.cs

@@ -1,60 +0,0 @@
-using System;
-using System.Linq.Expressions;
-using Luticate2.Auth.Business.Fields;
-using Luticate2.Auth.Dbo;
-using Luticate2.Auth.Dbo.Fields;
-using Luticate2.Auth.Dbo.Result;
-using Luticate2.Auth.Interfaces;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace Luticate2.Auth.Business.FieldsExpressions
-{
-    public class LuFieldsExpressions<TDbo, TModel> : ILuFieldsExpressions<TDbo, TModel>
-    {
-        protected IServiceProvider ServiceProvider { get; }
-
-        public LuFieldsExpressions(IServiceProvider serviceProvider)
-        {
-            ServiceProvider = serviceProvider;
-        }
-        
-        public ILuFieldsExpressions<TDbo2, TModel2> GetService<TDbo2, TModel2>()
-        {
-            var service = ServiceProvider.GetService<ILuFieldsExpressions<TDbo2, TModel2>>();
-            return service;
-        }
-
-        protected LuResult<Expression<Func<TType1, object>>> GetSubField<TType1, TType2, TType3>(
-            Expression<Func<TType1, TModel>> modelProperty, LuFieldDbo field, Expression<Func<TModel, TType3>> modelSubProperty)
-        {
-            var subPropExprResult = LuExpressionUtils.GetSingleMemberFromExpression(modelSubProperty);
-            if (subPropExprResult == null)
-            {
-                return LuResult<Expression<Func<TType1, object>>>.Error(LuStatus.InternalError.ToInt(), "Bad field expression");
-            }
-
-            var prop = Expression.Property(modelProperty.Body, subPropExprResult.Name);
-            var exp = Expression.Lambda<Func<TType1, TType3>>(prop, modelProperty.Parameters[0]);
-            var service = GetService<TType2, TType3>();
-            var finalExpResult = service.GetExpression(exp, field.Popped());
-            return finalExpResult;
-        }
-
-        protected virtual LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(
-            Expression<Func<TType1, TModel>> modelProperty, LuFieldDbo field)
-        {
-            return LuResult<Expression<Func<TType1, object>>>.Error(LuStatus.InputError.ToInt(), $"Unknown field: {field}", "");
-        }
-
-        public virtual LuResult<Expression<Func<TType1, object>>> GetExpression<TType1>(Expression<Func<TType1, TModel>> modelProperty, LuFieldDbo field)
-        {
-            if (field.IsRoot())
-            {
-                var converted = Expression.Convert(modelProperty.Body, typeof(object));
-                var exp = Expression.Lambda<Func<TType1, object>>(converted, modelProperty.Parameters[0]);
-                return LuResult<Expression<Func<TType1, object>>>.Ok(exp);
-            }
-            return GetExpressionInternal(modelProperty, field);
-        }
-    }
-}

Luticate2.Auth/Business/Pagination/LuFilterParser.cs

@@ -12,6 +12,10 @@ namespace Luticate2.Auth.Business.Pagination
     {
         public static LuResult<LuFilterDbo> Parse<T>(string data)
         {
+            if (string.IsNullOrWhiteSpace(data))
+            {
+                data = "true";
+            }
             var completeData = $"(x) => ({data})";
             try
             {
@@ -24,7 +28,7 @@ namespace Luticate2.Auth.Business.Pagination
             }
             catch (Exception e)
             {
-                return LuResult<LuFilterDbo>.Error(LuStatus.InputError.ToInt(), e);
+                return LuResult<LuFilterDbo>.Error(LuStatus.InputError.ToInt(), e, "Failed to parse filter expression");
             }
         }
     }

Luticate2.Auth/Interfaces/ILuExpressionConverter.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.Fields.DMEC;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Interfaces
+{
+    public interface ILuExpressionConverter
+    {
+        LuResult<Expression> ConvertExpression(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options);
+    }
+
+    public interface ILuExpressionConverter<TTypeFrom> : ILuExpressionConverter
+    {
+    }
+
+    public interface ILuExpressionConverter<TTypeFrom, TTypeTo> : ILuExpressionConverter<TTypeFrom>
+    {
+    }
+}

Luticate2.Auth/Interfaces/ILuFieldsExpressions.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Linq.Expressions;
-using Luticate2.Auth.Dbo.Fields;
-using Luticate2.Auth.Dbo.Result;
-
-namespace Luticate2.Auth.Interfaces
-{
-    public interface ILuFieldsExpressions<TDbo, TModel>
-    {
-        LuResult<Expression<Func<TType1, object>>> GetExpression<TType1>(Expression<Func<TType1, TModel>> modelProperty, LuFieldDbo field);
-    }
-}