Added options to configure expression parsing; parse oderBy and filter expressions; basic filter and orderBy working; removed Id property from LuObjectsDbo; added descriptors for groups and metadata

Luticate2.Auth.ConsoleSample/Commands/CreateCommand.cs

                 {
                     if (OutputType == "specific")
                     {
-                        Console.WriteLine($"{item.Id} {item.Name ?? "??"}");
+                        Console.WriteLine($"{item.Metadata.Id} {item.Name ?? "??"}");
                     }
                     else if (OutputType == "json-full")
                     {

Luticate2.Auth.ConsoleSample/Commands/ListCommand.cs

 using Luticate2.Auth.Utils.Business.Fields;
 using Luticate2.Auth.Utils.Business.Pagination;
 using Luticate2.Auth.Utils.Business.Serializers.PartialJson;
+using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo.Pagination;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using NClap.Metadata;
 using Newtonsoft.Json;
 
         [NamedArgument(DefaultValue = "")]
         public string Filter { get; set; }
 
-        [NamedArgument(DefaultValue = "id:asc")]
-        public string OrderBy { get; set; }
+        [NamedArgument(ArgumentFlags.Multiple)]
+        public string[] OrderBy { get; set; }
 
         [NamedArgument(DefaultValue = "0")]
         public int Page { get; set; }
             }
             else
             {
+                var parserOptions = Program.ServiceProvider.GetRequiredService<IOptions<LuExpressionUtils.LuExpressionParserOptions>>();
+
                 var partialResponseResult = LuPartialFieldsParser.Parse(PartialResponse);
                 if (!partialResponseResult)
                 {
                 }
                 var partialResponse = partialResponseResult.Data;
 
-                var filterResult = LuFilterParser.Parse<LuGroupDbo>(Filter);
+                var filterResult = LuFilterParser.Parse<LuGroupDbo>(Filter, parserOptions.Value);
                 if (!filterResult)
                 {
                     filterResult.WriteLineError();
                 }
                 var filter = filterResult.Data;
 
-                var orderByResult = LuOrderByParser.Parse(OrderBy);
+                var orderByResult = LuOrderByParser.Parse<LuGroupDbo>(OrderBy, parserOptions.Value);
                 if (!orderByResult)
                 {
                     orderByResult.WriteLineError();
                     {
                         if (OutputType == "specific")
                         {
-                            Console.WriteLine($"{item.Id} {item.Name ?? "??"}");
+                            Console.WriteLine($"{item.Metadata.Id} {item.Name ?? "??"}");
                         }
                         else if (OutputType == "json-full")
                         {

Luticate2.Auth.ConsoleSample/Program.cs

 using System;
+using System.Collections.Generic;
 using Luticate2.Auth.Auth.Business;
 using Luticate2.Auth.Auth.DataAccess;
+using Luticate2.Auth.Auth.DataAccess.Converters;
+using Luticate2.Auth.Auth.DataAccess.Models;
+using Luticate2.Auth.Auth.Dbo;
 using Luticate2.Auth.ConsoleSample.Commands;
 using Luticate2.Auth.Utils.Business.Converters;
+using Luticate2.Auth.Utils.Business.Utils;
+using Luticate2.Auth.Utils.Interfaces;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using NClap.Metadata;
         [Command(typeof(ExitCommand), Description = "Exits the shell")]
         Exit
     }
-    
+
     class Program
     {
         public static IServiceProvider ServiceProvider;
             IServiceCollection services = new ServiceCollection();
 
             services.AddLuObjectConverterDescriptors();
+            // DB Read
+            services.AddSingleton<ILuObjectConverterDescriptor<LuObjectsMetadataDbo, LuObjectsMetadata>, LuObjectsMetadataDboDescriptor>();
+            services.AddSingleton<ILuObjectConverterDescriptor<LuGroupDbo, LuGroups>, LuGroupsDboDescriptor>();
+            // DB Write
+
             services.AddLuObjectConverters();
-            
+            // DB read
+            services.AddLuObjectConverterPoco<LuObjectsMetadata, LuObjectsMetadataDbo>();
+            services.AddLuObjectConverterPoco<LuGroups, LuGroupDbo>();
+            // DB Write
+
+            // DB filter/orderBy
+            services.AddSingleton<ILuConvertersTypeConverter>(new LuConvertersTypeConverter(new Dictionary<Type, Type>
+            {
+                {typeof(LuGroupDbo), typeof(LuGroups)}
+            }));
+
             services.AddScoped<LuGroupsBusiness>();
 
+            services.AddLuOptions();
+            services.Configure<LuExpressionUtils.LuExpressionParserOptions>(options =>
+            {
+                options.ScriptOptions = options.ScriptOptions.AddReferences(typeof(Program).Assembly);
+            });
+
             services.AddDbContext<Luticate2DbContext>(options =>
             {
                 options.UseNpgsql(@"Host=localhost;Database=luticate2;Username=dev;Password=dev");
             }, ServiceLifetime.Transient);
 
             ServiceProvider = services.BuildServiceProvider();
-            
+
             var loop = new Loop(typeof(CommandsEnum));
             loop.Execute();
         }

Luticate2.Auth.Tests/Business/Pagination/LuFilterTests.cs

 using Luticate2.Auth.Auth.Dbo;
 using Luticate2.Auth.Utils.Business.Pagination;
+using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Result;
+using Microsoft.CodeAnalysis.Scripting;
 using Xunit;
 
 namespace Luticate2.Auth.Tests.Business.Pagination
         [Fact]
         public void Test1()
         {
-            var filterResult = LuFilterParser.Parse<LuGroupDbo>("x.Name.Contains(\"test\")");
+            var options = new LuExpressionUtils.LuExpressionParserOptions
+            {
+                ScriptOptions = ScriptOptions.Default.AddReferences(typeof(LuGroupDbo).Assembly)
+            };
+            var filterResult = LuFilterParser.Parse<LuGroupDbo>("x.Name.Contains(\"test\")", options);
             Assert.Equal(LuStatus.Success.ToInt(), filterResult.Status);
             Assert.NotNull(filterResult.Data);
         }

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

             {
                 Filter = new LuFilterDbo
                 {
-                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => true)
+                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1" || x.Name == "test2")
                 },
                 Page = 0,
                 OrderBy = new LuOrderByDbo
             {
                 Filter = new LuFilterDbo
                 {
-                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => true)
+                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1" || x.Name == "test2")
                 },
                 Page = 0,
                 OrderBy = new LuOrderByDbo

Luticate2.Auth/Auth/DataAccess/Converters/LuGroups.cs

+using Luticate2.Auth.Auth.DataAccess.Models;
+using Luticate2.Auth.Auth.Dbo;
+using Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor;
+
+namespace Luticate2.Auth.Auth.DataAccess.Converters
+{
+    public class LuGroupsDboDescriptor : LuObjectConverterDescriptor<LuGroupDbo, LuGroups>
+    {
+        public LuGroupsDboDescriptor()
+        {
+            AddStaticMemberConverter(x => x.Metadata, y => y.IdNavigation);
+            AddStaticMemberConverter(x => x.Name, y => y.Name);
+        }
+    }
+}

Luticate2.Auth/Auth/DataAccess/Converters/LuObjectsMetadata.cs

+using Luticate2.Auth.Auth.DataAccess.Models;
+using Luticate2.Auth.Auth.Dbo;
+using Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor;
+
+namespace Luticate2.Auth.Auth.DataAccess.Converters
+{
+    public class LuObjectsMetadataDboDescriptor : LuObjectConverterDescriptor<LuObjectsMetadataDbo, LuObjectsMetadata>
+    {
+        public LuObjectsMetadataDboDescriptor()
+        {
+            AddStaticMemberConverter(x => x.Id, y => y.Id.ToString());
+            AddStaticMemberConverter(x => x.CreatedAt, y => y.CreatedAt);
+            AddStaticMemberConverter(x => x.UpdatedAt, y => y.UpdatedAt);
+        }
+    }
+}

Luticate2.Auth/Auth/Dbo/LuObjectDbo.cs

-using System;
-
-namespace Luticate2.Auth.Auth.Dbo
+namespace Luticate2.Auth.Auth.Dbo
 {
     public class LuObjectDbo
     {
-        public Guid Id { get; set; }
-        
         public LuObjectsMetadataDbo Metadata { get; set; }
     }
 }

Luticate2.Auth/Auth/Dbo/LuObjectsMetadataDbo.cs

 {
     public class LuObjectsMetadataDbo
     {
-        public Guid Id { get; set; }
+        public string Id { get; set; }
 
         public DateTime CreatedAt { get; set; }
 

Luticate2.Auth/Luticate2.Auth.csproj

     <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
-    <Folder Include="Auth\DataAccess\Converters" />
     <Folder Include="Utils\DataAccess" />
   </ItemGroup>
   <ItemGroup>

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

                 return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
                     $"Converter descriptor lambda has incorrect number of arguments for {typeFrom} => {typeTo} => {methodCallExpression.Method}");
             }
-            if (valueExpression.Parameters[0].Type != typeTo)
+            if (typeTo != valueExpression.Parameters[0].Type && !valueExpression.Parameters[0].Type.IsAssignableFrom(typeTo))
             {
                 return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
                     $"Invalid conversion lambda for {typeFrom} => {typeTo}");

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

 using System.Linq;
 using Luticate2.Auth.Utils.Business.Converters.ObjectConverter;
 using Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor;
+using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Interfaces;
+using Microsoft.CodeAnalysis.Scripting;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 
         {
             services.AddSingleton<ILuObjectConverter<TTypeFrom, TTypeTo>, LuObjectConverterPoco<TTypeFrom, TTypeTo>>();
         }
+
+        public static void AddLuOptions(this IServiceCollection services)
+        {
+            services.AddOptions<LuExpressionUtils.LuExpressionParserOptions>().Configure(options =>
+            {
+                options.ScriptOptions = ScriptOptions.Default
+                    .AddReferences(typeof(LuExpressionUtils.LuExpressionParserOptions).Assembly)
+                    .AddImports("System.Linq.Enumerable");
+            });
+        }
     }
 }

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

 using System;
+using System.Linq;
 using Luticate2.Auth.Utils.Business.Fields;
 using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo;
                     continue;
                 }
 
-                var subSrcPropExpressionResult = descriptor.GetMemberValueExpression(memberInfo, options.DescriptorOptions);
+                // TODO Hack to deal with inherited members; need to check if it is correct
+                var originalMemberInfo = memberInfo.DeclaringType.GetMember(memberInfo.Name).First();
+
+                var subSrcPropExpressionResult = descriptor.GetMemberValueExpression(originalMemberInfo, options.DescriptorOptions);
                 if (!subSrcPropExpressionResult)
                 {
                     return subSrcPropExpressionResult.To<object>();

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

-using System;
-using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.Utils;
 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;
 
 namespace Luticate2.Auth.Utils.Business.Pagination
 {
     public class LuFilterParser
     {
-        public static LuResult<LuFilterDbo> Parse<T>(string data)
+        public static LuResult<LuFilterDbo> Parse<T>(string data, LuExpressionUtils.LuExpressionParserOptions options)
         {
             if (string.IsNullOrWhiteSpace(data))
             {
                     Expression = null
                 });
             }
+
             var completeData = $"(x) => ({data})";
-            try
-            {
-                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
-                {
-                    Expression = expr
-                });
-            }
-            catch (Exception e)
+            var expressionResult = LuExpressionUtils.Parse<T, bool>(completeData, options);
+
+            return expressionResult.Select(expression => new LuFilterDbo
             {
-                return LuResult<LuFilterDbo>.Error(LuStatus.InputError.ToInt(), e, "Failed to parse filter expression");
-            }
+                Expression = expression
+            });
         }
     }
 }

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

-using System.Collections.Generic;
-using Luticate2.Auth.Utils.Dbo;
+using System;
+using System.Collections.Generic;
+using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo.Pagination;
 using Luticate2.Auth.Utils.Dbo.Result;
 
 {
     public static class LuOrderByParser
     {
-        public static LuResult<LuOrderByDbo> Parse(string data)
+        public static LuResult<LuOrderByDbo> Parse<TDbo>(IEnumerable<string> data, LuExpressionUtils.LuExpressionParserOptions options)
         {
-            if (data == null)
+            var orderByDbo = new LuOrderByDbo
             {
-                data = "";
+                OrderByFields = new List<LuOrderByFieldDbo>()
+            };
+            foreach (var orderByFieldStr in data)
+            {
+                var orderByFieldResult = Parse<TDbo>(orderByFieldStr, options);
+                if (!orderByFieldResult)
+                {
+                    return orderByFieldResult.To<LuOrderByDbo>();
+                }
+                var orderByFieldDbo = orderByFieldResult.Data;
+
+                orderByDbo.OrderByFields.Add(orderByFieldDbo);
             }
-            data = data.Trim();
-            if (data != "")
+
+            return LuResult<LuOrderByDbo>.Ok(orderByDbo);
+        }
+
+        public static LuResult<LuOrderByFieldDbo> Parse<TDbo>(string data, LuExpressionUtils.LuExpressionParserOptions options)
+        {
+            var orderByFieldDbo = new LuOrderByFieldDbo();
+            if (data.EndsWith(":desc", StringComparison.OrdinalIgnoreCase))
             {
-                var dbo = new LuOrderByDbo {OrderByFields = new List<LuOrderByFieldDbo>()};
-                var fields = data.Split(',');
-                foreach (var field in fields)
+                orderByFieldDbo.Asc = false;
+                data = data.Substring(0, data.Length - 5);
+            }
+            else
+            {
+                orderByFieldDbo.Asc = true;
+
+                if (data.EndsWith(":asc", StringComparison.OrdinalIgnoreCase))
                 {
-                    if (field == "")
-                    {
-                        return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(),
-                            $"LuOrderByParser: {data}", "Empty order by field");
-                    }
-                    var orderByField = new LuOrderByFieldDbo();
-                    // 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);
+                    data = data.Substring(0, data.Length - 4);
                 }
-                return LuResult<LuOrderByDbo>.Ok(dbo);
             }
-            return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(), "Order by is empty or missing", "");
+
+            var completeData = $"(x) => ({data})";
+            var expressionResult = LuExpressionUtils.Parse<TDbo, object>(completeData, options);
+            if (!expressionResult)
+            {
+                return expressionResult.To<LuOrderByFieldDbo>();
+            }
+            orderByFieldDbo.Expression = expressionResult.Data;
+
+            return LuResult<LuOrderByFieldDbo>.Ok(orderByFieldDbo);
         }
     }
 }

Luticate2.Auth/Utils/Business/Utils/LuExpressionUtils.cs

 using System.Reflection;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Result;
+using Microsoft.CodeAnalysis.CSharp.Scripting;
+using Microsoft.CodeAnalysis.Scripting;
 
 namespace Luticate2.Auth.Utils.Business.Utils
 {
     public static class LuExpressionUtils
     {
+        public class LuExpressionParserOptions
+        {
+            public ScriptOptions ScriptOptions { get; set; }
+        }
+
         public static Expression GetFromConvert(Expression exp)
         {
             if (exp is LambdaExpression lambdaExpression)
 
             return null;
         }
+
+        public static LuResult<Expression<Func<TArg, TResult>>> Parse<TArg, TResult>(string data, LuExpressionParserOptions options)
+        {
+            try
+            {
+//                var options = ScriptOptions.Default.AddReferences(typeof(LuFilterParser).Assembly, typeof(Expression<>).Assembly);
+                var expr = CSharpScript.EvaluateAsync<Expression<Func<TArg, TResult>>>(data, options.ScriptOptions).Result;
+                return LuResult<Expression<Func<TArg, TResult>>>.Ok(expr);
+            }
+            catch (Exception e)
+            {
+                return LuResult<Expression<Func<TArg, TResult>>>.Error(LuStatus.InputError.ToInt(), e, "Failed to parse expression");
+            }
+        }
     }
 }

Luticate2.Auth/Utils/DataAccess/Crud/LuEfCrudDataAccess.cs

         public LuEfCrudDataAccess(IServiceProvider serviceProvider)
         {
             ServiceProvider = serviceProvider;
-            ConvertersAllocator = ServiceProvider.GetRequiredService<ILuConvertersAllocator>();
-            ConvertersTypeConverter = ServiceProvider.GetRequiredService<ILuConvertersTypeConverter>();
+            ConvertersAllocator = ServiceProvider.GetRequiredService<ILuConvertersAllocator>(); // TODO Make a DbContext or DataAccess specific ILuConvertersAllocator (in case of multiple DbContext)
+            ConvertersTypeConverter = ServiceProvider.GetRequiredService<ILuConvertersTypeConverter>(); // TODO same as above
         }
 
         protected virtual LuConvertersOptions GetOptions()
                 Allocator = ConvertersAllocator,
                 Parameters = new Dictionary<ParameterExpression, Expression>(),
                 TypeConverter = ConvertersTypeConverter
-            };// TODO
+            };
         }
 
         protected virtual LuResult<TModel> ConvertDboToModel(LuPartialFieldsDbo partialInput, TDbo dbo)
                 return LuResult<IQueryable<TModel>>.Ok(queryable);
             }
 
-            var lamdbaDbo = (Expression<Func<TDbo, bool>>) filter.Expression;
+            var lambdaDbo = (Expression<Func<TDbo, bool>>) filter.Expression;
 
             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));
+            var lambdaModel = converter.Visit(lambdaDbo) as Expression<Func<TModel, bool>>;// TODO Handle errors
+            return LuResult<IQueryable<TModel>>.Ok(queryable.Where(lambdaModel));
         }
 
         protected virtual LuResult<IQueryable<TModel>> OrderByField(LuOrderByFieldDbo orderByField, IQueryable<TModel> queryable)
         {
-            var lamdbaDbo = (Expression<Func<TDbo, object>>) orderByField.Expression;
+            var lambdaDbo = (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>>;
+            var lambdaModelNoConvert = converter.Visit(lambdaDbo) as LambdaExpression;// TODO Handle errors
+            var lambdaModel = Expression.Lambda<Func<TModel, object>>(lambdaModelNoConvert.Body, lambdaModelNoConvert.Parameters);
 
-            IOrderedQueryable<TModel> ordered = null;
+            IOrderedQueryable<TModel> ordered;
 
             if (queryable is IOrderedQueryable<TModel> orderedQueryable)
             {
                 if (orderByField.Asc)
                 {
-                    ordered = orderedQueryable.ThenBy(lamdbaModel);
+                    ordered = orderedQueryable.ThenBy(lambdaModel);
                 }
                 else
                 {
-                    ordered = orderedQueryable.ThenByDescending(lamdbaModel);
+                    ordered = orderedQueryable.ThenByDescending(lambdaModel);
                 }
             }
             else
             {
                 if (orderByField.Asc)
                 {
-                    ordered = queryable.OrderBy(lamdbaModel);
+                    ordered = queryable.OrderBy(lambdaModel);
                 }
                 else
                 {
-                    ordered = queryable.OrderByDescending(lamdbaModel);
+                    ordered = queryable.OrderByDescending(lambdaModel);
                 }
             }
 
             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)
                 {
                     return includeResult.To<LuPaginatedDbo<TDbo>>();
                 }
-
                 var included = includeResult.Data;
 
                 var orderByResult = OrderBy(paginationParams.OrderBy, included);
                 {
                     return orderByResult.To<LuPaginatedDbo<TDbo>>();
                 }
-
                 var ordered = orderByResult.Data;
                 
                 var filteredResult = Filter(paginationParams.Filter, ordered);
                 {
                     return filteredResult.To<LuPaginatedDbo<TDbo>>();
                 }
-
                 var filtered = filteredResult.Data;
                 var count = filtered.Count();
 
                 {
                     return paginatedResult.To<LuPaginatedDbo<TDbo>>();
                 }
-
                 var paginated = paginatedResult.Data;
 
-                var data = paginated.AsEnumerable().Select(model =>
+                var dboList = new List<TDbo>();
+                foreach (var model in paginated)
+                {
+                    var dboResult = ConvertModelToDbo(partialResponse, model);
+                    if (!dboResult)
                     {
-                        var convertResult = ConvertModelToDbo(partialResponse, model); // TODO Handle error
-                        return convertResult.Data;
-                    }).ToList();
+                        return dboResult.To<LuPaginatedDbo<TDbo>>();
+                    }
+                    var dbo = dboResult.Data;
+
+                    dboList.Add(dbo);
+                }
 
                 return LuResult<LuPaginatedDbo<TDbo>>.Ok(new LuPaginatedDbo<TDbo>
                 {
                     Count = count,
-                    Data = data
+                    Data = dboList
                 });
             });
             return result;

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

     {
         public long Count { get; set; }
 
-        public List<TDbo> Data { get; set; }
+        public IList<TDbo> Data { get; set; }
     }
 }