Added error handling; added tests; basic read from DB working

Luticate2.Auth.Tests/Business/ExpressionConverter/ExpressionConverterTests.cs

 using System.Linq;
 using System.Linq.Expressions;
 using Luticate2.Auth.Utils.Business.Converters;
-using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Business.Converters.ExpressionConverter;
 using Luticate2.Auth.Utils.Interfaces;
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;

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

 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
-using Luticate2.Auth.Utils.Business.ObjectConverterDescriptor;
+using Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor;
 
 namespace Luticate2.Auth.Tests.Business.ExpressionConverter
 {

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

 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
-using Luticate2.Auth.Utils.Business.ObjectConverterDescriptor;
+using Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor;
 
 namespace Luticate2.Auth.Tests.Business.ObjectConverter
 {

Luticate2.Auth.Tests/DataAccess/Crud/LuEfCrudTests.cs

+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Luticate2.Auth.Tests.DataAccess.Crud.Models;
+using Luticate2.Auth.Utils.Business.Converters;
+using Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor;
+using Luticate2.Auth.Utils.Business.Fields;
+using Luticate2.Auth.Utils.DataAccess.Crud;
+using Luticate2.Auth.Utils.Dbo;
+using Luticate2.Auth.Utils.Dbo.Fields;
+using Luticate2.Auth.Utils.Dbo.Pagination;
+using Luticate2.Auth.Utils.Dbo.Result;
+using Luticate2.Auth.Utils.Interfaces;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Luticate2.Auth.Tests.DataAccess.Crud
+{
+    public class LuEfCrudTests
+    {
+        public class TableSimple1Dbo
+        {
+            public Guid Id { get; set; }
+
+            public string Name { get; set; }
+
+            public int Priority { get; set; }
+
+            public string Comment { get; set; }
+
+            public int? OptionalInt { get; set; }
+
+            public DateTime CreatedAt { get; set; }
+
+            public DateTime? UpdatedAt { get; set; }
+        }
+
+        public class TableSimple1DboDescriptor : LuObjectConverterDescriptor<TableSimple1Dbo, table_simple_1>
+        {
+            public TableSimple1DboDescriptor()
+            {
+                AddStaticMemberConverter(dbo => dbo.Id, model => model.id);
+                AddStaticMemberConverter(dbo => dbo.Name, model => model.name);
+                AddStaticMemberConverter(dbo => dbo.Priority, model => model.priority);
+                AddStaticMemberConverter(dbo => dbo.Comment, model => model.comment);
+                AddStaticMemberConverter(dbo => dbo.OptionalInt, model => model.optional_int);
+                AddStaticMemberConverter(dbo => dbo.CreatedAt, model => model.created_at);
+                AddStaticMemberConverter(dbo => dbo.UpdatedAt, model => model.updated_at);
+            }
+        }
+
+        public class TableSimple1DataAccess : LuEfCrudDataAccess<TableSimple1Dbo, table_simple_1, luticate2_unit_testsContext>
+        {
+            public TableSimple1DataAccess(IServiceProvider serviceProvider) : base(serviceProvider)
+            {
+            }
+        }
+
+        protected IServiceProvider GetServiceProvider()
+        {
+            var services = new ServiceCollection();
+            services.AddLuObjectConverterDescriptors();
+            services.AddSingleton<ILuObjectConverterDescriptor<TableSimple1Dbo, table_simple_1>, TableSimple1DboDescriptor>();
+
+            services.AddLuObjectConverters();
+            services.AddLuObjectConverterPoco<table_simple_1, TableSimple1Dbo>(); // DB read
+
+            services.AddDbContext<luticate2_unit_testsContext>(options =>
+            {
+                options.UseNpgsql(@"Host=localhost;Database=luticate2_unit_tests;Username=dev;Password=dev");
+                options.UseInternalServiceProvider(new ServiceCollection()
+                    .AddEntityFrameworkNpgsql()
+                    .BuildServiceProvider());
+            }, ServiceLifetime.Transient);
+
+            services.AddSingleton<TableSimple1DataAccess>();
+            services.AddSingleton<ILuConvertersTypeConverter>(new LuConvertersTypeConverter(new Dictionary<Type, Type>
+            {
+                {typeof(TableSimple1Dbo), typeof(table_simple_1)} // DB read
+            }));
+
+            var serviceProvider = services.BuildServiceProvider();
+            return serviceProvider;
+        }
+
+        [Fact]
+        public void TestSimpleReadFilter1()
+        {
+            var serviceProvider = GetServiceProvider();
+
+            var crudDataAccess = serviceProvider.GetRequiredService<TableSimple1DataAccess>();
+
+            var result = crudDataAccess.Read(LuPartialFieldsParser.Parse("*").Data, new LuPaginatedParamsDbo
+            {
+                Filter = new LuFilterDbo
+                {
+                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1")
+                },
+                Page = 0,
+                OrderBy = new LuOrderByDbo
+                {
+                    OrderByFields = new List<LuOrderByFieldDbo>()
+                },
+                PerPage = 10
+            });
+            Assert.NotNull(result);
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var items = result.Data;
+            Assert.NotNull(items);
+            Assert.Equal(1, items.Count);
+            Assert.NotNull(items.Data);
+            Assert.Equal(1, items.Data.Count);
+
+            var item = items.Data[0];
+            Assert.NotNull(item);
+            Assert.Equal("test1", item.Name);
+            Assert.Equal(42, item.Priority);
+            Assert.Null(item.Comment);
+            Assert.Null(item.OptionalInt);
+        }
+
+        [Fact]
+        public void TestSimpleReadOrderBy1()
+        {
+            var serviceProvider = GetServiceProvider();
+
+            var crudDataAccess = serviceProvider.GetRequiredService<TableSimple1DataAccess>();
+
+            var result = crudDataAccess.Read(LuPartialFieldsParser.Parse("*").Data, new LuPaginatedParamsDbo
+            {
+                Filter = new LuFilterDbo
+                {
+                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => true)
+                },
+                Page = 0,
+                OrderBy = new LuOrderByDbo
+                {
+                    OrderByFields = new List<LuOrderByFieldDbo>
+                    {
+                        new LuOrderByFieldDbo
+                        {
+                            Asc = true,
+                            Expression = (Expression<Func<TableSimple1Dbo, object>>) (x => x.Priority)
+                        }
+                    }
+                },
+                PerPage = 10
+            });
+            Assert.NotNull(result);
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var items = result.Data;
+            Assert.NotNull(items);
+            Assert.Equal(2, items.Count);
+            Assert.NotNull(items.Data);
+            Assert.Equal(2, items.Data.Count);
+
+            var item = items.Data[0];
+            Assert.NotNull(item);
+            Assert.Equal("test2", item.Name);
+            Assert.Equal(24, item.Priority);
+            Assert.Null(item.Comment);
+            Assert.Equal(1, item.OptionalInt);
+
+            item = items.Data[1];
+            Assert.NotNull(item);
+            Assert.Equal("test1", item.Name);
+            Assert.Equal(42, item.Priority);
+            Assert.Null(item.Comment);
+            Assert.Null(item.OptionalInt);
+        }
+
+        [Fact]
+        public void TestSimpleReadOrderBy2()
+        {
+            var serviceProvider = GetServiceProvider();
+
+            var crudDataAccess = serviceProvider.GetRequiredService<TableSimple1DataAccess>();
+
+            var partialRespone = new LuPartialFieldsDbo
+            {
+                Fields = new List<LuFieldDbo>
+                {
+                    new LuFieldDbo
+                    {
+                        Parts = new List<string>
+                        {
+                            "*"
+                        }
+                    }
+                }
+            };
+
+            var paginationParams = new LuPaginatedParamsDbo
+            {
+                Filter = new LuFilterDbo
+                {
+                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => true)
+                },
+                Page = 0,
+                OrderBy = new LuOrderByDbo
+                {
+                    OrderByFields = new List<LuOrderByFieldDbo>
+                    {
+                        new LuOrderByFieldDbo
+                        {
+                            Asc = false,
+                            Expression = (Expression<Func<TableSimple1Dbo, object>>) (x => x.Priority)
+                        }
+                    }
+                },
+                PerPage = 10
+            };
+
+            var result = crudDataAccess.Read(partialRespone, paginationParams);
+            Assert.NotNull(result);
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var items = result.Data;
+            Assert.NotNull(items);
+            Assert.Equal(2, items.Count);
+            Assert.NotNull(items.Data);
+            Assert.Equal(2, items.Data.Count);
+
+            var item = items.Data[0];
+            Assert.NotNull(item);
+            Assert.Equal("test1", item.Name);
+            Assert.Equal(42, item.Priority);
+            Assert.Null(item.Comment);
+            Assert.Null(item.OptionalInt);
+
+            item = items.Data[1];
+            Assert.NotNull(item);
+            Assert.Equal("test2", item.Name);
+            Assert.Equal(24, item.Priority);
+            Assert.Null(item.Comment);
+            Assert.Equal(1, item.OptionalInt);
+        }
+    }
+}

Luticate2.Auth.Tests/DataAccess/Crud/Models/luticate2_unit_testsContext.cs

+using Microsoft.EntityFrameworkCore;
+
+namespace Luticate2.Auth.Tests.DataAccess.Crud.Models
+{
+    public partial class luticate2_unit_testsContext : DbContext
+    {
+        public luticate2_unit_testsContext()
+        {
+        }
+
+        public luticate2_unit_testsContext(DbContextOptions<luticate2_unit_testsContext> options)
+            : base(options)
+        {
+        }
+
+        public virtual DbSet<table_simple_1> table_simple_1 { get; set; }
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            if (!optionsBuilder.IsConfigured)
+            {
+#warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
+                optionsBuilder.UseNpgsql("Host=localhost;Database=luticate2_unit_tests;Username=dev;Password=dev");
+            }
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.HasPostgresExtension("uuid-ossp");
+
+            modelBuilder.Entity<table_simple_1>(entity =>
+            {
+                entity.Property(e => e.id).HasDefaultValueSql("uuid_generate_v1()");
+
+                entity.Property(e => e.comment).IsRequired();
+
+                entity.Property(e => e.created_at).HasColumnType("timestamp with time zone");
+
+                entity.Property(e => e.name).IsRequired();
+
+                entity.Property(e => e.updated_at).HasColumnType("timestamp with time zone");
+            });
+        }
+    }
+}

Luticate2.Auth.Tests/DataAccess/Crud/Models/table_simple_1.cs

+using System;
+
+namespace Luticate2.Auth.Tests.DataAccess.Crud.Models
+{
+    public partial class table_simple_1
+    {
+        public Guid id { get; set; }
+        public string name { get; set; }
+        public int priority { get; set; }
+        public string comment { get; set; }
+        public int? optional_int { get; set; }
+        public DateTime created_at { get; set; }
+        public DateTime? updated_at { get; set; }
+    }
+}

Luticate2.Auth.Tests/Luticate2.Auth.Tests.csproj

     <IsPackable>false</IsPackable>
   </PropertyGroup>
   <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.4" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.1.2" />
     <PackageReference Include="xunit" Version="2.3.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
     <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
   <ItemGroup>
     <ProjectReference Include="..\Luticate2.Auth\Luticate2.Auth.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="DataAccess\Crud\Models" />
+  </ItemGroup>
 </Project>

Luticate2.Auth.Tests/RandomTests.cs

-using Xunit;
+using System;
+using System.Linq.Expressions;
+using Luticate2.Auth.Tests.Business.ObjectConverter;
+using Luticate2.Auth.Utils.Business.Pagination;
+using Luticate2.Auth.Utils.Dbo;
+using Luticate2.Auth.Utils.Dbo.Pagination;
+using Luticate2.Auth.Utils.Dbo.Result;
+using Microsoft.CodeAnalysis.CSharp.Scripting;
+using Microsoft.CodeAnalysis.Scripting;
+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>();
-//        }
+        public static LuResult<LuFilterDbo> Parse<T>(string data)
+        {
+            if (string.IsNullOrWhiteSpace(data))
+            {
+                data = "true";
+            }
+            var completeData = $"(x) => ({data})";
+            try
+            {
+                var options = ScriptOptions.Default.AddReferences(typeof(RandomTests).Assembly,
+                    typeof(LuFilterParser).Assembly).AddImports("System.Linq.Enumerable");
+                var expr = CSharpScript.EvaluateAsync<Expression<Func<T, bool>>>(completeData, options).Result;
+                return LuResult<LuFilterDbo>.Ok(new LuFilterDbo
+                {
+                    Expression = expr
+                });
+            }
+            catch (Exception e)
+            {
+                return LuResult<LuFilterDbo>.Error(LuStatus.InputError.ToInt(), e, "Failed to parse filter expression");
+            }
+        }
 
         [Fact]
         public void Test()
 //            Expression<Func<TestDbo2, Guid>> expDbo = (x => parentScopeVar.Id);
 //            var type = typeof(ILuObjectConverterDescriptor<,>);
 //            var gtype = type.MakeGenericType(typeof(int), typeof(Enumerable));
+            var result = Parse<TestDbo1>("x.TestDbo2s.Any(y => y.Name == null)");
+//            var result = Parse<TestDbo1>("System.Linq.Enumerable.Any(x.TestDbo2s, y => y.Name == null)");
         }
 
     }

Luticate2.Auth/Auth/Business/LuGroupsBusiness.cs

 using Luticate2.Auth.Auth.DataAccess;
 using Luticate2.Auth.Auth.DataAccess.Models;
 using Luticate2.Auth.Auth.Dbo;
-using Luticate2.Auth.Utils.Business.Crud;
 using Luticate2.Auth.Utils.Business.Fields;
+using Luticate2.Auth.Utils.DataAccess.Crud;
 using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Result;
 using Microsoft.EntityFrameworkCore;
 
 namespace Luticate2.Auth.Auth.Business
 {
-    public class LuGroupsBusiness : LuEfCrudBusiness<LuGroupDbo, LuGroups, Luticate2DbContext>
+    public class LuGroupsBusiness : LuEfCrudDataAccess<LuGroupDbo, LuGroups, Luticate2DbContext>
     {
         public LuGroupsBusiness(IServiceProvider serviceProvider) : base(serviceProvider)
         {

Luticate2.Auth/Luticate2.Auth.csproj

     <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
-    <Folder Include="Utils" />
+    <Folder Include="Auth\DataAccess\Converters" />
+    <Folder Include="Utils\DataAccess" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="2.8.2" />

Luticate2.Auth/Utils/Business/ExpressionConverter/LuExpressionConverterVisitor.cs → Luticate2.Auth/Utils/Business/Converters/ExpressionConverter/LuExpressionConverterVisitor.cs

 using Luticate2.Auth.Utils.Exceptions;
 using Luticate2.Auth.Utils.Interfaces;
 
-namespace Luticate2.Auth.Utils.Business.ExpressionConverter
+namespace Luticate2.Auth.Utils.Business.Converters.ExpressionConverter
 {
     public interface ILuExpressionConverterVisitorOptions
     {
             }
         }
 
-        protected ILuObjectConverterDescriptor GetConverterDescriptor(Type typeFrom, Type typeTo)
+        protected LuResult<ILuObjectConverterDescriptor> GetConverterDescriptor(Type typeFrom, Type typeTo)
         {
             var type = typeof(ILuObjectConverterDescriptor<,>);
             var gtype = type.MakeGenericType(typeFrom, typeTo);
             {
                 descriptor = (ILuObjectConverterDescriptor) ServiceProvider.GetService(typeof(ILuObjectConverterDescriptorIdentity));
             }
-            return descriptor;
+
+            if (descriptor != null)
+            {
+                return LuResult<ILuObjectConverterDescriptor>.Ok(descriptor);
+            }
+
+            return LuResult<ILuObjectConverterDescriptor>.Error(LuStatus.InternalError.ToInt(),
+                $"Could not find converter descriptor for {typeFrom} => {typeTo}");
         }
 
         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)
+            var descriptorResult = GetConverterDescriptor(typeFrom, typeTo);
+            if (!descriptorResult)
             {
-                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
-                    $"Could not find converter descriptor for {typeFrom} => {typeTo}");
+                return descriptorResult.To<Expression>();
             }
+            var descriptor = descriptorResult.Data;
 
-            var valueExpression = descriptor.GetMemberValueExpression(memberExpression.Member, Options.DescriptorOptions);
-            if (valueExpression == null)
+            var valueExpressionResult = descriptor.GetMemberValueExpression(memberExpression.Member, Options.DescriptorOptions);
+            if (!valueExpressionResult)
             {
-                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
-                    $"Could not find converter descriptor lambda for {typeFrom} => {typeTo} => {memberExpression.Member}");
+                return valueExpressionResult.To<Expression>();
             }
+            var valueExpression = valueExpressionResult.Data;
+
             if (valueExpression.Parameters[0].Type != typeTo)
             {
                 return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
             var visitor = new LuExpressionParamReplaceVisitor(Options.VisitorOptions);
             newExpression = visitor.Visit(valueExpression.Body);
 
-            if (newExpression != null)
-            {
-                Options.Parameters.Remove(valueExpression.Parameters[0]);
-            }
+            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)
+            var descriptorResult = GetConverterDescriptor(typeFrom, typeTo);
+            if (!descriptorResult)
             {
-                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
-                    $"Could not find converter descriptor for {typeFrom} => {typeTo}");
+                return descriptorResult.To<Expression>();
             }
+            var descriptor = descriptorResult.Data;
 
-            var valueExpression = descriptor.GetMethodValueExpression(methodCallExpression.Method, Options.DescriptorOptions);
-            if (valueExpression == null)
+            var valueExpressionResult = descriptor.GetMethodValueExpression(methodCallExpression.Method, Options.DescriptorOptions);
+            if (!valueExpressionResult)
             {
-                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
-                    $"Could not find converter descriptor lambda for {typeFrom} => {typeTo} => {methodCallExpression.Method}");
+                return valueExpressionResult.To<Expression>();
             }
+            var valueExpression = valueExpressionResult.Data;
+
             if (valueExpression.Parameters.Count != methodCallExpression.Arguments.Count + 1)
             {
                 return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
             else if (currentExp is MemberExpression memberExpression)
             {
                 var typeFrom = memberExpression.Member.DeclaringType;
-                var typeTo = Options.TypeConverter.ConvertType(typeFrom);
+                var typeToResult = Options.TypeConverter.ConvertType(typeFrom);
+                if (!typeToResult)
+                {
+                    return typeToResult.To<Expression>();
+                }
+                var typeTo = typeToResult.Data;
 
                 var convertResult = ConvertMemberExpression(memberExpression, null, typeTo);
                 if (!convertResult)
             else if (currentExp is MethodCallExpression methodCallExpression)
             {
                 var typeFrom = methodCallExpression.Method.DeclaringType;
-                var typeTo = Options.TypeConverter.ConvertType(typeFrom);
+
+                var typeToResult = Options.TypeConverter.ConvertType(typeFrom);
+                if (!typeToResult)
+                {
+                    return typeToResult.To<Expression>();
+                }
+                var typeTo = typeToResult.Data;
 
                 var convertResult = ConvertMethodCallExpression(methodCallExpression, null, typeTo);
                 if (!convertResult)
                 {
                     return convertResult;
                 }
-
                 newExpression = convertResult.Data;
             }
             else
             var convertedParams = new List<ParameterExpression>();
             foreach (var parameter in node.Parameters)
             {
-                var convertedParam = Expression.Parameter(Options.TypeConverter.ConvertType(parameter.Type));
+                var convertedTypeResult = Options.TypeConverter.ConvertType(parameter.Type).ThrowIfNotSuccess();
+                var convertedType = convertedTypeResult.Data;
+                var convertedParam = Expression.Parameter(convertedType);
                 Options.Parameters.Add(parameter, convertedParam);
                 convertedParams.Add(convertedParam);
             }
+
             var convertedBody = Visit(node.Body);
             foreach (var parameter in node.Parameters)
             {

Luticate2.Auth/Utils/Business/ExpressionConverter/LuExpressionParamReplaceVisitor.cs → Luticate2.Auth/Utils/Business/Converters/ExpressionConverter/LuExpressionParamReplaceVisitor.cs

 using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Exceptions;
 
-namespace Luticate2.Auth.Utils.Business.ExpressionConverter
+namespace Luticate2.Auth.Utils.Business.Converters.ExpressionConverter
 {
     public interface ILuExpressionParamReplaceVisitorOptions
     {

Luticate2.Auth/Utils/Business/Converters/LuConvertersAllocator.cs

 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using Luticate2.Auth.Utils.Dbo;
+using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 
 namespace Luticate2.Auth.Utils.Business.Converters
             {typeof(List<>), typeof(List<>)}
         };
 
-        public virtual object GetInstance(Type type)
+        public virtual LuResult<object> CreateInstance(Type type)
+        {
+            try
+            {
+                var obj = Activator.CreateInstance(type);
+                // TODO Nullable<T> (and maybe others) gets null instead of object
+//                if (obj != null)
+//                {
+                    return LuResult<object>.Ok(obj);
+//                }
+
+//                return LuResult<object>.Error(LuStatus.InternalError.ToInt(),
+//                    $"Could not instantiate type {type}");
+            }
+            catch (Exception e)
+            {
+                return LuResult<object>.Error(LuStatus.InternalError.ToInt(), e);
+            }
+        }
+
+        public virtual LuResult<object> GetInstance(Type type)
         {
             if (type.IsGenericType)
             {
                 if (listTypes.ContainsKey(gtype))
                 {
                     var glistType = listTypes[gtype].MakeGenericType(type.GenericTypeArguments[0]);
-                    return Activator.CreateInstance(glistType);
+                    var listActivateResult = CreateInstance(glistType);
+                    return listActivateResult;
                 }
             }
 
-            if (type == typeof(string) || type.IsPrimitive)
+            if (type == typeof(string))
             {
-                return null;
+                return LuResult<object>.Ok("");
             }
 
-            return Activator.CreateInstance(type);
+            var activateResult = CreateInstance(type);
+            return activateResult;
         }
     }
 }

Luticate2.Auth/Utils/Business/Converters/LuConvertersExtensions.cs

+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
-using Luticate2.Auth.Utils.Business.ObjectConverter;
-using Luticate2.Auth.Utils.Business.ObjectConverterDescriptor;
+using Luticate2.Auth.Utils.Business.Converters.ObjectConverter;
+using Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor;
 using Luticate2.Auth.Utils.Interfaces;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 {
     public static class LuConvertersExtensions
     {
+        public class LuObjectConvertersOptions
+        {
+            public List<Type> ValueTypes { get; set; }
+
+            public List<Type> ListTypes { get; set; }
+        }
+
         public static void AddLuObjectConverterDescriptors(this IServiceCollection services)
         {
             var typeILuObjectConverterDescriptor = typeof(ILuObjectConverterDescriptor<,>);
             services.AddSingleton(typeILuObjectConverterDescriptorEnumerable, typeof(LuObjectConverterDescriptorEnumerable));
         }
 
-        public static void AddLuObjectConverters(this IServiceCollection services)
+        public static void AddLuObjectConverters(this IServiceCollection services, Action<LuObjectConvertersOptions> optionsAction = null)
         {
             var typeILuObjectConverter = typeof(ILuObjectConverter<,>);
-            var listTypes = new []
+
+            var options = new LuObjectConvertersOptions
             {
-                typeof(IEnumerable<>),
-                typeof(ICollection<>),
-                typeof(Collection<>),
-                typeof(IList<>),
-                typeof(List<>)
+                ValueTypes = new List<Type>
+                {
+                    typeof(bool),
+
+                    typeof(decimal),
+                    typeof(double),
+                    typeof(float),
+
+                    typeof(sbyte),
+                    typeof(byte),
+                    typeof(char),
+                    typeof(short),
+                    typeof(ushort),
+                    typeof(int),
+                    typeof(uint),
+                    typeof(long),
+                    typeof(ulong),
+
+                    typeof(Guid),
+
+                    typeof(DateTime),
+                    typeof(DateTimeOffset),
+                    typeof(TimeSpan)
+                },
+                ListTypes = new List<Type>
+                {
+                    typeof(IEnumerable<>),
+                    typeof(ICollection<>),
+                    typeof(Collection<>),
+                    typeof(IList<>),
+                    typeof(List<>)
+                }
             };
 
+            optionsAction?.Invoke(options);
+
             services.TryAddSingleton<ILuConvertersAllocator, LuConvertersAllocator>();
             services.AddSingleton<ILuObjectConverterIdentity, LuObjectConverterIdentity>();
-            foreach (var typeFrom in listTypes)
+            foreach (var valueType in options.ValueTypes)
+            {
+                var nullableValueType = typeof(Nullable<>).MakeGenericType(valueType);
+                var converterType = typeILuObjectConverter.MakeGenericType(valueType, nullableValueType);
+                services.AddSingleton(converterType, typeof(LuObjectConverterIdentity));
+            }
+            foreach (var typeFrom in options.ListTypes)
             {
-                foreach (var typeTo in listTypes)
+                foreach (var typeTo in options.ListTypes)
                 {
                     services.AddSingleton(typeILuObjectConverter.MakeGenericType(typeFrom, typeTo), typeof(LuObjectConverterLists));
                 }

Luticate2.Auth/Utils/Business/Converters/LuConvertersOptions.cs

 using System.Collections.Generic;
 using System.Linq.Expressions;
-using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Business.Converters.ExpressionConverter;
 using Luticate2.Auth.Utils.Interfaces;
 
 namespace Luticate2.Auth.Utils.Business.Converters

Luticate2.Auth/Utils/Business/Converters/LuConvertersTypeConverter.cs

 using System;
 using System.Collections.Generic;
+using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 
 namespace Luticate2.Auth.Utils.Business.Converters
             Types = types;
         }
 
-        public Type ConvertType(Type typeFrom)
+        public LuResult<Type> ConvertType(Type typeFrom)
         {
             if (Types.ContainsKey(typeFrom))
             {
-                return Types[typeFrom];
+                return LuResult<Type>.Ok(Types[typeFrom]);
             }
 
-            return typeFrom;
+            return LuResult<Type>.Ok(typeFrom);
         }
     }
 }

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterIdentity.cs → Luticate2.Auth/Utils/Business/Converters/ObjectConverter/LuObjectConverterIdentity.cs

 using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 
-namespace Luticate2.Auth.Utils.Business.ObjectConverter
+namespace Luticate2.Auth.Utils.Business.Converters.ObjectConverter
 {
     public class LuObjectConverterIdentity : ILuObjectConverterIdentity
     {

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterLists.cs → Luticate2.Auth/Utils/Business/Converters/ObjectConverter/LuObjectConverterLists.cs

 using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 
-namespace Luticate2.Auth.Utils.Business.ObjectConverter
+namespace Luticate2.Auth.Utils.Business.Converters.ObjectConverter
 {
     public class LuObjectConverterLists : ILuObjectConverter
     {
 
         public LuResult<object> Convert(object srcObj, object dstObj, LuFieldDbo path, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
         {
+            var dstObjType = dstObj.GetType();
+            var addMethodInfo = dstObjType.GetMethod(nameof(ICollection<object>.Add));
+            if (addMethodInfo == null)
+            {
+                return LuResult<object>.Error(LuStatus.InternalError.ToInt(),
+                    $"Could not find get method info {nameof(ICollection)}.{nameof(ICollection<object>.Add)} for type {dstObjType}");
+            }
+
             if (srcObj is IEnumerable enumerable)
             {
                 foreach (var subSrcObj in enumerable)
                     if (subSrcObj != null)
                     {
                         var typeFrom = subSrcObj.GetType();
-                        var typeTo = options.TypeConverter.ConvertType(typeFrom);
-                        // TODO Handle converter == null
-                        var converter = LuObjectConverterUtils.GetObjectConverter(ServiceProvider, typeFrom, typeTo);
-                        var subDstObj = options.Allocator.GetInstance(typeTo);
+
+                        var typeToResult = options.TypeConverter.ConvertType(typeFrom);
+                        if (!typeToResult)
+                        {
+                            return typeToResult.To<object>();
+                        }
+                        var typeTo = typeToResult.Data;
+
+                        var converterResult = LuObjectConverterUtils.GetObjectConverter(ServiceProvider, typeFrom, typeTo);
+                        if (!converterResult)
+                        {
+                            return converterResult.To<object>();
+                        }
+                        var converter = converterResult.Data;
+
+                        var subDstObjResult = options.Allocator.GetInstance(typeTo);
+                        if (!subDstObjResult)
+                        {
+                            return subDstObjResult.To<object>();
+                        }
+                        var subDstObj = subDstObjResult.Data;
+
                         var convertResult = converter.Convert(subSrcObj, subDstObj, path, fields, options);
                         if (!convertResult)
                         {
                             return convertResult;
                         }
-
                         convertedObj = convertResult.Data;
                     }
 
-                    var methodInfo = dstObj.GetType().GetMethod(nameof(ICollection<object>.Add));
-                    methodInfo.Invoke(dstObj, new []{convertedObj});
+                    addMethodInfo.Invoke(dstObj, new []{convertedObj});
                 }
 
                 return LuResult<object>.Ok(dstObj);

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterPoco.cs → Luticate2.Auth/Utils/Business/Converters/ObjectConverter/LuObjectConverterPoco.cs

 using System;
 using Luticate2.Auth.Utils.Business.Fields;
 using Luticate2.Auth.Utils.Business.Utils;
+using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace Luticate2.Auth.Utils.Business.ObjectConverter
+namespace Luticate2.Auth.Utils.Business.Converters.ObjectConverter
 {
     public class LuObjectConverterPoco<TTypeFrom, TTypeTo> : ILuObjectConverter<TTypeFrom, TTypeTo>
     {
             {
                 return LuResult<object>.Ok(default(TTypeTo));
             }
-            // TODO Handle descriptor == null
-            var descriptor = ServiceProvider.GetService<ILuObjectConverterDescriptor<TTypeTo, TTypeFrom>>();
+
             var typeTo = typeof(TTypeTo);
-//            var dstObj = options.Allocator.GetInstance(typeTo);
+            var descriptor = ServiceProvider.GetService<ILuObjectConverterDescriptor<TTypeTo, TTypeFrom>>();
+            if (descriptor == null)
+            {
+                return LuResult<object>.Error(LuStatus.InternalError.ToInt(),
+                    $"Could not find converter descriptor for {typeTo} => {typeof(TTypeFrom)}");
+            }
 
             foreach (var memberInfo in typeTo.GetProperties())
             {
                 {
                     continue;
                 }
-                // TODO Handle srcPropExpression == null
-                var subSrcPropExpression = descriptor.GetMemberValueExpression(memberInfo, options.DescriptorOptions);
+
+                var subSrcPropExpressionResult = descriptor.GetMemberValueExpression(memberInfo, options.DescriptorOptions);
+                if (!subSrcPropExpressionResult)
+                {
+                    return subSrcPropExpressionResult.To<object>();
+                }
+                var subSrcPropExpression = subSrcPropExpressionResult.Data;
+
                 var subSrcPropDelegate = subSrcPropExpression.Compile();
                 var subSrcProp = subSrcPropDelegate.DynamicInvoke(srcObj);
                 var subSrcType = subSrcProp != null ? subSrcProp.GetType() : subSrcPropExpression.ReturnType;
                 var subDstType = memberInfo.GetUnderlyingType();
 
-                // TODO Handle objectConverter == null
-                var objectConverter = LuObjectConverterUtils.GetObjectConverter(ServiceProvider, subSrcType, subDstType);
-                var subDstObj = options.Allocator.GetInstance(subDstType);
+                var objectConverterResult = LuObjectConverterUtils.GetObjectConverter(ServiceProvider, subSrcType, subDstType);
+                if (!objectConverterResult)
+                {
+                    return objectConverterResult.To<object>();
+                }
+                var objectConverter = objectConverterResult.Data;
+
+                var subDstObjResult = options.Allocator.GetInstance(subDstType);
+                if (!subDstObjResult)
+                {
+                    return subDstObjResult.To<object>();
+                }
+                var subDstObj = subDstObjResult.Data;
+
                 var dstPropResult = objectConverter.Convert(subSrcProp, subDstObj, memberPath, fields, options);
                 if (!dstPropResult)
                 {
                     return dstPropResult;
                 }
-
                 var dstProp = dstPropResult.Data;
 
                 var result = LuExpressionUtils.SetValueFromMember(memberInfo, dstObj, dstProp);

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterUtils.cs → Luticate2.Auth/Utils/Business/Converters/ObjectConverter/LuObjectConverterUtils.cs

 using System;
+using Luticate2.Auth.Utils.Dbo;
+using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 
-namespace Luticate2.Auth.Utils.Business.ObjectConverter
+namespace Luticate2.Auth.Utils.Business.Converters.ObjectConverter
 {
     public static class LuObjectConverterUtils
     {
-        public static ILuObjectConverter GetObjectConverter(IServiceProvider serviceProvider, Type typeFrom, Type typeTo)
+        public static LuResult<ILuObjectConverter> GetObjectConverter(IServiceProvider serviceProvider, Type typeFrom, Type typeTo)
         {
             var type = typeof(ILuObjectConverter<,>);
             var gtype = type.MakeGenericType(typeFrom, typeTo);
                 converter = (ILuObjectConverter) serviceProvider.GetService(typeof(ILuObjectConverterIdentity));
             }
 
-            return converter;
+            if (converter != null)
+            {
+                return LuResult<ILuObjectConverter>.Ok(converter);
+            }
+
+            return LuResult<ILuObjectConverter>.Error(LuStatus.InternalError.ToInt(),
+                $"Could not find converter for {typeFrom} => {typeTo}");
         }
     }
 }

Luticate2.Auth/Utils/Business/ObjectConverterDescriptor/LuObjectConverterDescriptor.cs → Luticate2.Auth/Utils/Business/Converters/ObjectConverterDescriptor/LuObjectConverterDescriptor.cs

 using System.Linq.Expressions;
 using System.Reflection;
 using Luticate2.Auth.Utils.Business.Utils;
+using Luticate2.Auth.Utils.Dbo;
+using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 
-namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
+namespace Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor
 {
     public class LuObjectConverterDescriptor : ILuObjectConverterDescriptor
     {
                 (info, converter) =>
                 {
                     var genericMethodInfo = info.GetGenericMethodDefinition();
-                    var templateMethodInfo = genericMethodInfo.MakeGenericMethod(info.GetGenericArguments().Select(converter.ConvertType).ToArray());
+                    // TODO Handle converter.ConvertType(type) errors
+                    var templateMethodInfo = genericMethodInfo.MakeGenericMethod(info.GetGenericArguments().Select(type => converter.ConvertType(type).Data).ToArray());
 
                     var lambdaParams = new List<ParameterExpression>
                     {
             );
         }
 
-        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options)
+        public LuResult<LambdaExpression> GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options)
         {
             if (StaticMemberConverters.ContainsKey(memberInfo))
             {
-                return StaticMemberConverters[memberInfo].ValueExpression;
+                return LuResult<LambdaExpression>.Ok(StaticMemberConverters[memberInfo].ValueExpression);
             }
 
-            return null;
+            return LuResult<LambdaExpression>.Error(LuStatus.InternalError.ToInt(),
+                $"Could not get member value expression from member info {memberInfo}");
         }
 
-        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options)
+        public LuResult<LambdaExpression> GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options)
         {
             if (StaticMethodConverters.ContainsKey(methodInfo))
             {
-                return StaticMethodConverters[methodInfo].ValueExpression;
+                return LuResult<LambdaExpression>.Ok(StaticMethodConverters[methodInfo].ValueExpression);
             }
 
             var genericMethodInfo = methodInfo.GetGenericMethodDefinition();
                 var result = DynamicMethodConverters[genericMethodInfo](methodInfo, options.TypeConverter);
                 if (result != null)
                 {
-                    return result.ValueExpression;
+                    return LuResult<LambdaExpression>.Ok(result.ValueExpression);
                 }
             }
 
-            return null;
+            return LuResult<LambdaExpression>.Error(LuStatus.InternalError.ToInt(),
+                $"Could not get method value expression from method info {methodInfo}");
         }
     }
 

Luticate2.Auth/Utils/Business/ObjectConverterDescriptor/LuObjectConverterDescriptorEnumerable.cs → Luticate2.Auth/Utils/Business/Converters/ObjectConverterDescriptor/LuObjectConverterDescriptorEnumerable.cs

 using System.Linq;
 using System.Linq.Expressions;
 
-namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
+namespace Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor
 {
     public class LuObjectConverterDescriptorEnumerable : LuObjectConverterDescriptor
     {

Luticate2.Auth/Utils/Business/ObjectConverterDescriptor/LuObjectConverterDescriptorIdentity.cs → Luticate2.Auth/Utils/Business/Converters/ObjectConverterDescriptor/LuObjectConverterDescriptorIdentity.cs

 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 
-namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
+namespace Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor
 {
     public class LuObjectConverterDescriptorIdentity : ILuObjectConverterDescriptorIdentity
     {
-        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options)
+        public LuResult<LambdaExpression> GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options)
         {
             var isStatic = false;
             if (memberInfo is FieldInfo fieldInfo)
             var param = Expression.Parameter(memberInfo.DeclaringType);
             var memberExpression = Expression.MakeMemberAccess(isStatic ? null : param, memberInfo);
             var lambda = Expression.Lambda(memberExpression, param);
-            return lambda;
+            return LuResult<LambdaExpression>.Ok(lambda);
         }
 
-        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options)
+        public LuResult<LambdaExpression> GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options)
         {
             var lambdaParams = new List<ParameterExpression>
             {
             lambdaParams.AddRange(methodParams);
             var methodCallExpression = Expression.Call(methodInfo.IsStatic ? null : lambdaParams[0], methodInfo, methodParams);
             var lambda = Expression.Lambda(methodCallExpression, lambdaParams);
-            return lambda;
+            return LuResult<LambdaExpression>.Ok(lambda);
         }
     }
 }

Luticate2.Auth/Utils/Business/ObjectConverterDescriptor/LuObjectConverterDescriptorDbSet.cs → Luticate2.Auth/Utils/Business/Converters/ObjectConverterDescriptor/LuObjectConverterDescriptorQueryable.cs

 using System.Linq.Expressions;
 using Microsoft.EntityFrameworkCore;
 
-namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
+namespace Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor
 {
-    public class LuObjectConverterDescriptorDbSet : LuObjectConverterDescriptor
+    public class LuObjectConverterDescriptorQueryable : LuObjectConverterDescriptor
     {
-        public LuObjectConverterDescriptorDbSet()
+        public LuObjectConverterDescriptorQueryable()
         {
             AddDynamicMethodConverterTemplate(
                 (Expression<Func<DbSet<object>, Expression<Func<object, bool>>, bool>>)((source, filter) => source.Any(filter)));

Luticate2.Auth/Utils/Business/Pagination/LuFilterParser.cs

         {
             if (string.IsNullOrWhiteSpace(data))
             {
-                data = "true";
+                return LuResult<LuFilterDbo>.Ok(new LuFilterDbo
+                {
+                    Expression = null
+                });
             }
             var completeData = $"(x) => ({data})";
             try
             {
-                var options = ScriptOptions.Default.AddReferences(typeof(LuFilterParser).Assembly);
+                var options = ScriptOptions.Default.AddReferences(typeof(LuFilterParser).Assembly, typeof(Expression<>).Assembly);
                 var expr = CSharpScript.EvaluateAsync<Expression<Func<T, bool>>>(completeData, options).Result;
                 return LuResult<LuFilterDbo>.Ok(new LuFilterDbo
                 {

Luticate2.Auth/Utils/Business/Pagination/LuOrderByParser.cs

 using System.Collections.Generic;
 using Luticate2.Auth.Utils.Dbo;
-using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Pagination;
 using Luticate2.Auth.Utils.Dbo.Result;
 
                             $"LuOrderByParser: {data}", "Empty order by field");
                     }
                     var orderByField = new LuOrderByFieldDbo();
-                    var split = field.Split(':');
-                    if (split.Length > 2 || split.Length == 0)
-                    {
-                        return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(),
-                            $"LuOrderByParser: {data}", "Invalid order by field syntax");
-                    }
-                    orderByField.Field = LuFieldDbo.Make(split[0]);
-                    var order = split.Length == 2 ? split[1].ToLower() : "asc";
-                    if (order == "asc")
-                    {
-                        orderByField.Asc = true;
-                    }
-                    else if (order == "desc")
-                    {
-                        orderByField.Asc = false;
-                    }
-                    else
-                    {
-                        return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(),
-                            $"LuOrderByParser: {data}", "Empty order by field order");
-                    }
+                    // TODO parse
+//                    var split = field.Split(':');
+//                    if (split.Length > 2 || split.Length == 0)
+//                    {
+//                        return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(),
+//                            $"LuOrderByParser: {data}", "Invalid order by field syntax");
+//                    }
+//                    orderByField.Field = LuFieldDbo.Make(split[0]);
+//                    var order = split.Length == 2 ? split[1].ToLower() : "asc";
+//                    if (order == "asc")
+//                    {
+//                        orderByField.Asc = true;
+//                    }
+//                    else if (order == "desc")
+//                    {
+//                        orderByField.Asc = false;
+//                    }
+//                    else
+//                    {
+//                        return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(),
+//                            $"LuOrderByParser: {data}", "Empty order by field order");
+//                    }
                     dbo.OrderByFields.Add(orderByField);
                 }
                 return LuResult<LuOrderByDbo>.Ok(dbo);

Luticate2.Auth/Utils/Business/Crud/LuEfCrudBusiness.cs → Luticate2.Auth/Utils/DataAccess/Crud/LuEfCrudDataAccess.cs

 using System.Linq;
 using System.Linq.Expressions;
 using Luticate2.Auth.Utils.Business.Converters;
-using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Business.Converters.ExpressionConverter;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Pagination;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace Luticate2.Auth.Utils.Business.Crud
+namespace Luticate2.Auth.Utils.DataAccess.Crud
 {
-    public class LuEfCrudBusiness<TDbo, TModel, TDbContext> : ILuCrud<TDbo>
+    public class LuEfCrudDataAccess<TDbo, TModel, TDbContext> : ILuCrud<TDbo>
         where TModel : class
         where TDbContext : DbContext
-        where TDbo : class, new()
+        where TDbo : class
     {
         protected IServiceProvider ServiceProvider { get; }
         protected ILuConvertersAllocator ConvertersAllocator { get; }
+        protected ILuConvertersTypeConverter ConvertersTypeConverter { get; }
 
-        public LuEfCrudBusiness(IServiceProvider serviceProvider)
+        public LuEfCrudDataAccess(IServiceProvider serviceProvider)
         {
             ServiceProvider = serviceProvider;
             ConvertersAllocator = ServiceProvider.GetRequiredService<ILuConvertersAllocator>();
+            ConvertersTypeConverter = ServiceProvider.GetRequiredService<ILuConvertersTypeConverter>();
         }
 
-        protected virtual ILuObjectConverterOptions GetOptions()
+        protected virtual LuConvertersOptions GetOptions()
         {
             return new LuConvertersOptions
             {
-                Allocator = ConvertersAllocator
+                Allocator = ConvertersAllocator,
+                Parameters = new Dictionary<ParameterExpression, Expression>(),
+                TypeConverter = ConvertersTypeConverter
             };// TODO
         }
 
             }
 
             var options = GetOptions();
-            var dstObj = options.Allocator.GetInstance(typeof(TModel));
+            var dstObjResult = options.Allocator.GetInstance(typeof(TModel));
+            if (!dstObjResult)
+            {
+                return dstObjResult.To<TModel>();
+            }
+            var dstObj = dstObjResult.Data;
             var result = copier.Convert(dbo, dstObj, new LuFieldDbo(), partialInput, GetOptions());
             return result.Select(o => o as TModel);
         }
             }
 
             var options = GetOptions();
-            var dstObj = options.Allocator.GetInstance(typeof(TDbo));
+            var dstObjResult = options.Allocator.GetInstance(typeof(TDbo));
+            if (!dstObjResult)
+            {
+                return dstObjResult.To<TDbo>();
+            }
+            var dstObj = dstObjResult.Data;
+
             var result = copier.Convert(model, dstObj, new LuFieldDbo(), partialResponse, GetOptions());
             return result.Select(o => o as TDbo);
         }
 
         protected virtual LuResult<IQueryable<TModel>> Filter(LuFilterDbo filter, IQueryable<TModel> queryable)
         {
+            if (filter.Expression == null)
+            {
+                return LuResult<IQueryable<TModel>>.Ok(queryable);
+            }
+
             var lamdbaDbo = (Expression<Func<TDbo, bool>>) filter.Expression;
 
-            var options = new LuConvertersOptions
-            {
-                Parameters = new Dictionary<ParameterExpression, Expression>(), // TODO
-                TypeConverter = null, // TODO
-                Allocator = ConvertersAllocator
-            };
+            var options = GetOptions();
             var converter = new LuExpressionConverterVisitor(options, ServiceProvider);
             var lamdbaModel = converter.Visit(lamdbaDbo) as Expression<Func<TModel, bool>>;// TODO Handle errors
             return LuResult<IQueryable<TModel>>.Ok(queryable.Where(lamdbaModel));
         }
 
-        protected virtual LuResult<IQueryable<TModel>> OrderByField(LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable)
+        protected virtual LuResult<IQueryable<TModel>> OrderByField(LuOrderByFieldDbo orderByField, IQueryable<TModel> queryable)
         {
+            var lamdbaDbo = (Expression<Func<TDbo, object>>) orderByField.Expression;
+
+            var options = GetOptions();
+            var converter = new LuExpressionConverterVisitor(options, ServiceProvider);
+            var lamdbaModel = converter.Visit(lamdbaDbo) as Expression<Func<TModel, object>>;
+
+            IOrderedQueryable<TModel> ordered = null;
+
+            if (queryable is IOrderedQueryable<TModel> orderedQueryable)
+            {
+                if (orderByField.Asc)
+                {
+                    ordered = orderedQueryable.ThenBy(lamdbaModel);
+                }
+                else
+                {
+                    ordered = orderedQueryable.ThenByDescending(lamdbaModel);
+                }
+            }
+            else
+            {
+                if (orderByField.Asc)
+                {
+                    ordered = queryable.OrderBy(lamdbaModel);
+                }
+                else
+                {
+                    ordered = queryable.OrderByDescending(lamdbaModel);
+                }
+            }
+
+            return LuResult<IQueryable<TModel>>.Ok(ordered);
+
 //            var expressionBuilder = ServiceProvider.GetService<ILuDboModelExpressionConverter<TDbo, TModel>>();
 //            var expressionResult = expressionBuilder.ConvertLamdba<TModel>(orderByfield.);
 //            if (!expressionResult)
 //            var ordered = queryable.OrderBy(expressionNoConvert);
 //
 //            return LuResult<IQueryable<TModel>>.Ok(ordered);
-            return LuResult<IQueryable<TModel>>.Ok(queryable);
+//            return LuResult<IQueryable<TModel>>.Ok(queryable);
         }
 
         protected virtual LuResult<IQueryable<TModel>> OrderBy(LuOrderByDbo orderBy, IQueryable<TModel> queryable)

Luticate2.Auth/Utils/Dbo/Pagination/LuOrderByFieldDbo.cs

-using Luticate2.Auth.Utils.Dbo.Fields;
+using System.Linq.Expressions;
 
 namespace Luticate2.Auth.Utils.Dbo.Pagination
 {
     public class LuOrderByFieldDbo
     {
-        public LuFieldDbo Field { get; set; }
+        public Expression Expression { get; set; }
 
         public bool Asc { get; set; } = true;
-
-        public override string ToString()
-        {
-            var asc = Asc ? "ASC" : "DESC";
-            return $"{string.Join(".", Field)}:{asc}";
-        }
     }
 }

Luticate2.Auth/Utils/Interfaces/ILuConvertersAllocator.cs

 using System;
+using Luticate2.Auth.Utils.Dbo.Result;
 
 namespace Luticate2.Auth.Utils.Interfaces
 {
     public interface ILuConvertersAllocator
     {
-        object GetInstance(Type type);
+        LuResult<object> GetInstance(Type type);
     }
 }

Luticate2.Auth/Utils/Interfaces/ILuConvertersTypeConverter.cs

 using System;
+using Luticate2.Auth.Utils.Dbo.Result;
 
 namespace Luticate2.Auth.Utils.Interfaces
 {
     public interface ILuConvertersTypeConverter
     {
-        Type ConvertType(Type typeFrom);
+        LuResult<Type> ConvertType(Type typeFrom);
     }
 }

Luticate2.Auth/Utils/Interfaces/ILuObjectConverterDescriptor.cs

 using System.Linq.Expressions;
 using System.Reflection;
+using Luticate2.Auth.Utils.Dbo.Result;
 
 namespace Luticate2.Auth.Utils.Interfaces
 {
 
     public interface ILuObjectConverterDescriptor
     {
-        LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options);
+        LuResult<LambdaExpression> GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options);
 
-        LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options);
+        LuResult<LambdaExpression> GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options);
     }
 
     public interface ILuObjectConverterDescriptor<TTypeFrom, TTypeTo> : ILuObjectConverterDescriptor