crud interface get multiple with order by; tests

Luticate2.Auth/Controllers/LuticateExtensions.cs

-using Luticate2.Auth.Business;
+using System.Collections.Generic;
+using Luticate2.Auth.Business;
 using Luticate2.Auth.DataAccess;
 using Luticate2.Auth.Middlewares;
+using Luticate2.Utils.Controllers;
 using Luticate2.Utils.Dbo.OrderBy;
 using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.DependencyInjection;
 
             app.UseMiddleware<LuAuthMiddleware>();
             return app;
         }
+
+        public static object GetLuCurrentUser(this HttpContext context)
+        {
+            return context.GetLuItems()["currentUser"];//TODO
+        }
     }
 }

Luticate2.Utils/Business/LuCrudBusiness.cs

 using System;
 using System.Collections.Generic;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Interfaces;
 
 namespace Luticate2.Utils.Business
         where TDboRead : class
         where TDboUpdate : class
     {
-        protected readonly TNextCrud Db;
+        protected readonly TNextCrud NextCrud;
 
-        protected LuCrudBusiness(TNextCrud db)
+        protected LuCrudBusiness(TNextCrud nextCrud)
         {
-            Db = db;
+            NextCrud = nextCrud;
         }
 
         protected virtual LuResult<TDboCreate> CheckAdd(TDboCreate obj)
             {
                 return res.To<T>();
             }
-            return Db.Add(res.Data, returnFunc);
+            return NextCrud.Add(res.Data, returnFunc);
         }
 
         public LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
             {
                 return res.To<T>();
             }
-            return Db.Add(res.Data, returnFunc);
+            return NextCrud.Add(res.Data, returnFunc);
         }
 
         public LuResult<IEnumerable<string>> AddGuid(IEnumerable<TDboCreate> objs)
             {
                 return res.To<IEnumerable<string>>();
             }
-            return Db.AddGuid(res.Data);
+            return NextCrud.AddGuid(res.Data);
         }
 
         public LuResult<string> AddGuid(TDboCreate obj)
             {
                 return res.To<string>();
             }
-            return Db.AddGuid(res.Data);
+            return NextCrud.AddGuid(res.Data);
         }
 
         public LuResult<IEnumerable<long>> AddId(IEnumerable<TDboCreate> obj)
             {
                 return res.To<IEnumerable<long>>();
             }
-            return Db.AddId(res.Data);
+            return NextCrud.AddId(res.Data);
         }
 
         public LuResult<long> AddId(TDboCreate obj)
             {
                 return res.To<long>();
             }
-            return Db.AddId(res.Data);
+            return NextCrud.AddId(res.Data);
         }
 
         public LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
             {
                 return res.To<IEnumerable<TDboRead>>();
             }
-            return Db.AddDbo(res.Data);
+            return NextCrud.AddDbo(res.Data);
         }
 
         public LuResult<TDboRead> AddDbo(TDboCreate obj)
             {
                 return res.To<TDboRead>();
             }
-            return Db.AddDbo(res.Data);
+            return NextCrud.AddDbo(res.Data);
         }
 
 
 
         public LuResult<TDboRead> GetSingleByKeys(params KeyValuePair<string, object>[] keys)
         {
-            return Db.GetSingleByKeys(keys);
+            return NextCrud.GetSingleByKeys(keys);
         }
 
         public LuResult<TDboRead> GetSingleById(string id)
         {
-            return Db.GetSingleById(id);
+            return NextCrud.GetSingleById(id);
         }
 
         public LuResult<TDboRead> GetSingleById(long id)
         {
-            return Db.GetSingleById(id);
+            return NextCrud.GetSingleById(id);
+        }
+
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        {
+            return NextCrud.GetMultiple(orderBy, 0, perPage);
         }
 
 
             {
                 return obj.To<T>();
             }
-            return Db.EditSingleById(id, obj.Data, returnFunc);
+            return NextCrud.EditSingleById(id, obj.Data, returnFunc);
         }
 
         public LuResult<long> EditSingleByIdId(long id, TDboUpdate update)
             {
                 return obj.To<long>();
             }
-            return Db.EditSingleByIdId(id, obj.Data);
+            return NextCrud.EditSingleByIdId(id, obj.Data);
         }
 
         public LuResult<TDboRead> EditSingleByIdDbo(long id, TDboUpdate update)
             {
                 return obj.To<TDboRead>();
             }
-            return Db.EditSingleByIdDbo(id, obj.Data);
+            return NextCrud.EditSingleByIdDbo(id, obj.Data);
         }
 
         public LuResult<T> EditSingleById<T>(string id, TDboUpdate update, Func<TDboRead, T> returnFunc)
             {
                 return obj.To<T>();
             }
-            return Db.EditSingleById(id, obj.Data, returnFunc);
+            return NextCrud.EditSingleById(id, obj.Data, returnFunc);
         }
 
         public LuResult<string> EditSingleByIdGuid(string id, TDboUpdate update)
             {
                 return obj.To<string>();
             }
-            return Db.EditSingleByIdGuid(id, obj.Data);
+            return NextCrud.EditSingleByIdGuid(id, obj.Data);
         }
 
         public LuResult<TDboRead> EditSingleByIdDbo(string id, TDboUpdate update)
             {
                 return obj.To<TDboRead>();
             }
-            return Db.EditSingleByIdDbo(id, obj.Data);
+            return NextCrud.EditSingleByIdDbo(id, obj.Data);
         }
 
 
 
         public LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc)
         {
-            return Db.DeleteSingleById(id, returnFunc);
+            return NextCrud.DeleteSingleById(id, returnFunc);
         }
 
         public LuResult<string> DeleteSingleByIdGuid(string id)
         {
-            return Db.DeleteSingleByIdGuid(id);
+            return NextCrud.DeleteSingleByIdGuid(id);
         }
 
         public LuResult<TDboRead> DeleteSingleByIdDbo(string id)
         {
-            return Db.DeleteSingleByIdDbo(id);
+            return NextCrud.DeleteSingleByIdDbo(id);
         }
 
         public LuResult<T> DeleteSingleById<T>(long id, Func<TDboRead, T> returnFunc)
         {
-            return Db.DeleteSingleById(id, returnFunc);
+            return NextCrud.DeleteSingleById(id, returnFunc);
         }
 
         public LuResult<long> DeleteSingleByIdId(long id)
         {
-            return Db.DeleteSingleByIdId(id);
+            return NextCrud.DeleteSingleByIdId(id);
         }
 
         public LuResult<TDboRead> DeleteSingleByIdDbo(long id)
         {
-            return Db.DeleteSingleByIdDbo(id);
+            return NextCrud.DeleteSingleByIdDbo(id);
         }
     }
 }

Luticate2.Utils/Controllers/LuController.cs

     {
         protected IConnectionManager ConnectionManager { get; set; }
 
-        protected IDictionary<object, object> LuItems => (IDictionary<object, object>) HttpContext.Items["luticateItems"];
-
-//        protected UsersDbo LuCurrentUser => (UsersDbo) LuItems["luticateItems"];
+        protected IDictionary<object, object> LuItems => HttpContext.GetLuItems();
 
         protected T Handle<T>(LuResult<T> result)
         {

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

+using System.Collections.Generic;
+using Microsoft.AspNetCore.Http;
+
+namespace Luticate2.Utils.Controllers
+{
+    public static class LuUtilsExtensions
+    {
+        public static IDictionary<object, object> GetLuItems(this HttpContext context)
+        {
+            return (IDictionary<object, object>) context.Items["luticateItems"];
+        }
+    }
+}

Luticate2.Utils/DataAccess/LuEfCrudInterface.cs → Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Reflection;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Interfaces;
 using Microsoft.EntityFrameworkCore;
 
 namespace Luticate2.Utils.DataAccess
 {
-    public abstract class LuEfCrudInterface<TModel, TDboCreate, TDboRead, TDboUpdate, TDbContext> :
+    public abstract class LuEfCrudDataAccess<TModel, TDboCreate, TDboRead, TDboUpdate, TDbContext> :
             LuEfDataAccess<TModel, TDbContext>, ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
         where TModel : class
         where TDboCreate : class
         where TDboUpdate : class
         where TDbContext : DbContext
     {
-        protected LuEfCrudInterface(TDbContext db, DbSet<TModel> table) : base(db, table)
+        protected LuEfCrudDataAccess(TDbContext db, DbSet<TModel> table) : base(db, table)
         {
         }
 
 
         protected abstract TDboRead GetDboFromModel(TModel model);
 
+        protected string GetFieldName(string name)
+        {
+            return
+                string.Concat(name.Select((x, i) => i > 0 && char.IsUpper(x) ? "_" + x.ToString() : x.ToString()))
+                    .ToLower();
+        }
+
         protected Func<TDboRead, T> GetIdFunc<T>()
         {
             var param = Expression.Parameter(typeof(TDboRead), "x");
         }
 
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<DbSet<TModel>, IQueryable<TModel>> orderBy,
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<DbSet<TModel>, IOrderedQueryable<TModel>> orderBy,
             Expression<Func<TModel, bool>> predicate, int page = 0, int perPage = int.MaxValue,
-            params Func<DbSet<TModel>, IQueryable<TModel>>[] otherOrderBy)
+            params Func<IOrderedQueryable<TModel>, IOrderedQueryable<TModel>>[] otherOrderBy)
         {
             return Execute(() =>
             {
                 var ordered = orderBy(Table);
                 foreach (var func in otherOrderBy)
                 {
-                    ordered = func(Table);
+                    ordered = func(ordered);
                 }
                 var data = ordered.Where(predicate).Skip(page * perPage).Take(perPage).Select(GetDboFromModel).ToList();
                 var result = new LuPaginatedDbo<TDboRead>
             params Expression<Func<TModel, object>>[] otherOrderBy)
         {
             return GetMultiple(table => table.OrderBy(orderBy), predicate, page, perPage,
-                otherOrderBy.Select<Expression<Func<TModel, object>>, Func<DbSet<TModel>,
-                    IQueryable<TModel>>>(expression => (t => t.OrderBy(expression))).ToArray());
+                otherOrderBy.Select<Expression<Func<TModel, object>>, Func<IOrderedQueryable<TModel>,
+                    IOrderedQueryable<TModel>>>(expression => (t => t.ThenBy(expression))).ToArray());
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<DbSet<TModel>, IQueryable<TModel>> orderBy,
-            int page = 0, int perPage = int.MaxValue, params Func<DbSet<TModel>, IQueryable<TModel>>[] otherOrderBy)
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<DbSet<TModel>, IOrderedQueryable<TModel>> orderBy,
+            int page = 0, int perPage = int.MaxValue, params Func<IOrderedQueryable<TModel>, IOrderedQueryable<TModel>>[] otherOrderBy)
         {
             return GetMultiple(orderBy, x => true, page, perPage, otherOrderBy);
         }
         public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Expression<Func<TModel, object>> orderBy,
             int page = 0, int perPage = int.MaxValue, params Expression<Func<TModel, object>>[] otherOrderBy)
         {
-            return GetMultiple(table => table.OrderBy(orderBy), x => true, page, perPage,
-                otherOrderBy.Select<Expression<Func<TModel, object>>, Func<DbSet<TModel>,
-                    IQueryable<TModel>>>(expression => (t => t.OrderBy(expression))).ToArray());
+            return GetMultiple(orderBy, x => true, page, perPage, otherOrderBy);
         }
 
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        {
+            return Execute(() =>
+            {
+                var count = Table.Count();
+                IOrderedQueryable<TModel> ordered = null;
+                foreach (var field in orderBy.Fields)
+                {
+                    var fieldName = GetFieldName(field.Name);
+                    var param = Expression.Parameter(typeof(TModel), "x");
+                    var prop = Expression.Property(param, fieldName);
+                    var converted = Expression.Convert(prop, typeof(object));
+                    var exp = Expression.Lambda<Func<TModel, object>>(converted, param);
+                    if (ordered != null)
+                    {
+                        ordered = field.Asc ? ordered.ThenBy(exp) : ordered.ThenByDescending(exp);
+                    }
+                    else
+                    {
+                        ordered = field.Asc ? Table.OrderBy(exp) : Table.OrderByDescending(exp);
+                    }
+                }
+
+                var data = ordered.Skip(page * perPage).Take(perPage).Select(GetDboFromModel).ToList();
+                var result = new LuPaginatedDbo<TDboRead>
+                {
+                    Count = count,
+                    Data = data
+                };
+                return LuResult<LuPaginatedDbo<TDboRead>>.Ok(result);
+            });
+        }
 
 
 

Luticate2.Utils/Dbo/OrderBy/LuOrderByBinder.cs

     {
         public static LuResult<LuOrderByDbo> FromString(string data)
         {
+            if (data == null)
+            {
+                data = "";
+            }
             data = data.Trim();
             var dbo = new LuOrderByDbo {Fields = new List<LuOrderByFieldDbo>()};
             if (data != "")

Luticate2.Utils/Interfaces/ILuCrudInterface.cs

 using System;
 using System.Collections.Generic;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.OrderBy;
 
 namespace Luticate2.Utils.Interfaces
 {
         LuResult<TDboRead> GetSingleById(long id);
 
 
+        LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue);
+
+
+
 
         LuResult<T> EditSingleById<T>(long id, TDboUpdate update, Func<TDboRead, T> returnFunc);
 

Test/Utils/DataAccess/LuUtilsPkBigSerialDataAccess.cs

 
 namespace Test.Utils.DataAccess
 {
-    public class LuUtilsPkBigSerialDataAccess : LuEfCrudInterface<pk_bigserial, PkBigSerialAddDbo, PkBigSerialDbo, PkBigSerialAddDbo, LuUtilsDbContext>
+    public class LuUtilsPkBigSerialDataAccess : LuEfCrudDataAccess<pk_bigserial, PkBigSerialAddDbo, PkBigSerialDbo, PkBigSerialAddDbo, LuUtilsDbContext>
     {
         public LuUtilsPkBigSerialDataAccess(LuUtilsDbContext db) : base(db, db.pk_bigserial)
         {

Test/Utils/DataAccess/LuUtilsPkGuidDataAccess.cs

 
 namespace Test.Utils.DataAccess
 {
-    public class LuUtilsPkGuidDataAccess : LuEfCrudInterface<pk_guid, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, LuUtilsDbContext>
+    public class LuUtilsPkGuidDataAccess : LuEfCrudDataAccess<pk_guid, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, LuUtilsDbContext>
     {
         public LuUtilsPkGuidDataAccess(LuUtilsDbContext db) : base(db, db.pk_guid)
         {

Test/Utils/EfCrudDataAccess/LuEfReadDataAccessTest.cs

 using System.Collections.Generic;
 using System.Linq;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.OrderBy;
 using Test.Utils.DataAccess;
 using Test.Utils.Dbo.PkBigSerial;
 using Test.Utils.Dbo.PkGuid;
 using Xunit;
 
-namespace Test.Utils.EfCrubDataAccess
+namespace Test.Utils.EfCrudDataAccess
 {
     public class LuEfReadDataAccessTest
     {
                     },
                     new PkGuidAddDbo
                     {
-                        SomeInt = 24,
+                        SomeInt = 142,
                         SomeText = "24"
                     }
                 };
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var get = service.GetMultiple(table => table.OrderBy(guid => guid.some_int),
-                    guid => guid.some_int == 42, 0, int.MaxValue, set => set.OrderBy(guid => guid.some_text));
-
+                    guid => guid.some_int == 42, 0, int.MaxValue, set => set.ThenBy(guid => guid.some_text));
                 Assert.Equal(LuStatus.Success, get.Status);
                 Assert.Equal(2, get.Data.Count);
                 Assert.Equal(2, get.Data.Data.Count);
                     },
                     new PkGuidAddDbo
                     {
-                        SomeInt = 24,
+                        SomeInt = 142,
                         SomeText = "24"
                     }
                 };
 
                 var get = service.GetMultiple(guid => guid.some_int, guid => guid.some_int == 42, 0, int.MaxValue,
                     guid => guid.some_text);
-
                 Assert.Equal(LuStatus.Success, get.Status);
                 Assert.Equal(2, get.Data.Count);
                 Assert.Equal(2, get.Data.Data.Count);
                     },
                     new PkGuidAddDbo
                     {
-                        SomeInt = 24,
+                        SomeInt = 142,
                         SomeText = "24"
                     }
                 };
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var get = service.GetMultiple(table => table.OrderBy(guid => guid.some_int), 0, int.MaxValue,
-                    set => set.OrderBy(guid => guid.some_text));
-
+                    set => set.ThenBy(guid => guid.some_text));
                 Assert.Equal(LuStatus.Success, get.Status);
                 Assert.Equal(3, get.Data.Count);
                 Assert.Equal(3, get.Data.Data.Count);
 
                 var dbo = get.Data.Data[0];
-                Assert.Equal(24, dbo.SomeInt);
-                Assert.Equal("24", dbo.SomeText);
-
-                dbo = get.Data.Data[1];
                 Assert.Equal(42, dbo.SomeInt);
                 Assert.Equal("42", dbo.SomeText);
 
-                dbo = get.Data.Data[2];
+                dbo = get.Data.Data[1];
                 Assert.Equal(42, dbo.SomeInt);
                 Assert.Equal("442", dbo.SomeText);
+
+                dbo = get.Data.Data[2];
+                Assert.Equal(142, dbo.SomeInt);
+                Assert.Equal("24", dbo.SomeText);
             });
         }
 
                     },
                     new PkGuidAddDbo
                     {
-                        SomeInt = 24,
+                        SomeInt = 142,
                         SomeText = "24"
                     }
                 };
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var get = service.GetMultiple(guid => guid.some_int, 0, int.MaxValue, guid => guid.some_text);
-
                 Assert.Equal(LuStatus.Success, get.Status);
                 Assert.Equal(3, get.Data.Count);
                 Assert.Equal(3, get.Data.Data.Count);
 
                 var dbo = get.Data.Data[0];
-                Assert.Equal(24, dbo.SomeInt);
-                Assert.Equal("24", dbo.SomeText);
+                Assert.Equal(42, dbo.SomeInt);
+                Assert.Equal("42", dbo.SomeText);
 
                 dbo = get.Data.Data[1];
                 Assert.Equal(42, dbo.SomeInt);
+                Assert.Equal("442", dbo.SomeText);
+
+                dbo = get.Data.Data[2];
+                Assert.Equal(142, dbo.SomeInt);
+                Assert.Equal("24", dbo.SomeText);
+            });
+        }
+
+        [Fact]
+        public void TestGetMultiple5()
+        {
+            Tests.TestRealDb(context =>
+            {
+                var dbos = new List<PkGuidAddDbo>
+                {
+                    new PkGuidAddDbo
+                    {
+                        SomeInt = 42,
+                        SomeText = "442"
+                    },
+                    new PkGuidAddDbo
+                    {
+                        SomeInt = 42,
+                        SomeText = "42"
+                    },
+                    new PkGuidAddDbo
+                    {
+                        SomeInt = 142,
+                        SomeText = "24"
+                    }
+                };
+                var service = new LuUtilsPkGuidDataAccess(context);
+                var res = service.AddGuid(dbos);
+                Assert.Equal(LuStatus.Success, res.Status);
+
+                var orderBy = LuOrderByBinder.FromString("someInt,someText");
+                Assert.Equal(LuStatus.Success, orderBy.Status);
+
+                var get = service.GetMultiple(orderBy.Data);
+                Assert.Equal(LuStatus.Success, get.Status);
+                Assert.Equal(3, get.Data.Count);
+                Assert.Equal(3, get.Data.Data.Count);
+
+                var dbo = get.Data.Data[0];
+                Assert.Equal(42, dbo.SomeInt);
                 Assert.Equal("42", dbo.SomeText);
 
+                dbo = get.Data.Data[1];
+                Assert.Equal(42, dbo.SomeInt);
+                Assert.Equal("442", dbo.SomeText);
+
                 dbo = get.Data.Data[2];
+                Assert.Equal(142, dbo.SomeInt);
+                Assert.Equal("24", dbo.SomeText);
+            });
+        }
+
+        [Fact]
+        public void TestGetMultiple6()
+        {
+            Tests.TestRealDb(context =>
+            {
+                var dbos = new List<PkGuidAddDbo>
+                {
+                    new PkGuidAddDbo
+                    {
+                        SomeInt = 42,
+                        SomeText = "442"
+                    },
+                    new PkGuidAddDbo
+                    {
+                        SomeInt = 42,
+                        SomeText = "42"
+                    },
+                    new PkGuidAddDbo
+                    {
+                        SomeInt = 142,
+                        SomeText = "24"
+                    }
+                };
+                var service = new LuUtilsPkGuidDataAccess(context);
+                var res = service.AddGuid(dbos);
+                Assert.Equal(LuStatus.Success, res.Status);
+
+                var orderBy = LuOrderByBinder.FromString("someText:desc,someInt");
+                Assert.Equal(LuStatus.Success, orderBy.Status);
+
+                var get = service.GetMultiple(orderBy.Data);
+                Assert.Equal(LuStatus.Success, get.Status);
+                Assert.Equal(3, get.Data.Count);
+                Assert.Equal(3, get.Data.Data.Count);
+
+                var dbo = get.Data.Data[0];
                 Assert.Equal(42, dbo.SomeInt);
                 Assert.Equal("442", dbo.SomeText);
+
+                dbo = get.Data.Data[1];
+                Assert.Equal(42, dbo.SomeInt);
+                Assert.Equal("42", dbo.SomeText);
+
+                dbo = get.Data.Data[2];
+                Assert.Equal(142, dbo.SomeInt);
+                Assert.Equal("24", dbo.SomeText);
             });
         }
     }

WebTest/Business/PkGuidBusiness.cs

 {
     public class PkGuidBusiness : LuCrudBusiness<LuUtilsPkGuidDataAccess, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo>
     {
-        public PkGuidBusiness(LuUtilsPkGuidDataAccess db) : base(db)
+        public PkGuidBusiness(LuUtilsPkGuidDataAccess nextCrud) : base(nextCrud)
         {
         }
     }

WebTest/Controllers/PkGuidController.cs

-using Luticate2.Utils.Controllers;
+using System.Collections.Generic;
+using Luticate2.Utils.Controllers;
+using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.OrderBy;
 using Microsoft.AspNetCore.Mvc;
 using Test.Utils.Dbo.PkGuid;
         }
 
         [Route("[controller]")]
-        public PkGuidDbo Get(LuOrderByDbo orderBy)
+        public LuPaginatedDbo<PkGuidDbo> Get(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
         {
-            return new PkGuidDbo();
-//            return Handle(_busines.GetMultiple());
+            return Handle(_busines.GetMultiple(orderBy, page, perPage));
         }
     }
 }