crud controller

Luticate2.Utils/Business/LuCrudBusiness.cs

 
 namespace Luticate2.Utils.Business
 {
-    public abstract class LuCrudBusiness<TNextCrud, TDboCreate, TDboRead, TDboUpdate> : LuBusiness, ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
-        where TNextCrud : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
+    public abstract class LuCrudBusiness<TDataAccess, TDboCreate, TDboRead, TDboUpdate> : LuBusiness, ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
+        where TDataAccess : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
         where TDboCreate : class
         where TDboRead : class
         where TDboUpdate : class
     {
-        protected readonly TNextCrud NextCrud;
+        protected readonly TDataAccess DataAccess;
 
-        protected LuCrudBusiness(TNextCrud nextCrud)
+        protected LuCrudBusiness(TDataAccess dataAccess)
         {
-            NextCrud = nextCrud;
+            DataAccess = dataAccess;
         }
 
         protected virtual LuResult<TDboCreate> CheckAdd(TDboCreate obj)
             {
                 return res.To<T>();
             }
-            return NextCrud.Add(res.Data, returnFunc);
+            return DataAccess.Add(res.Data, returnFunc);
         }
 
         public LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
             {
                 return res.To<T>();
             }
-            return NextCrud.Add(res.Data, returnFunc);
+            return DataAccess.Add(res.Data, returnFunc);
         }
 
         public LuResult<IEnumerable<string>> AddGuid(IEnumerable<TDboCreate> objs)
             {
                 return res.To<IEnumerable<string>>();
             }
-            return NextCrud.AddGuid(res.Data);
+            return DataAccess.AddGuid(res.Data);
         }
 
         public LuResult<string> AddGuid(TDboCreate obj)
             {
                 return res.To<string>();
             }
-            return NextCrud.AddGuid(res.Data);
+            return DataAccess.AddGuid(res.Data);
         }
 
         public LuResult<IEnumerable<long>> AddId(IEnumerable<TDboCreate> obj)
             {
                 return res.To<IEnumerable<long>>();
             }
-            return NextCrud.AddId(res.Data);
+            return DataAccess.AddId(res.Data);
         }
 
         public LuResult<long> AddId(TDboCreate obj)
             {
                 return res.To<long>();
             }
-            return NextCrud.AddId(res.Data);
+            return DataAccess.AddId(res.Data);
         }
 
         public LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
             {
                 return res.To<IEnumerable<TDboRead>>();
             }
-            return NextCrud.AddDbo(res.Data);
+            return DataAccess.AddDbo(res.Data);
         }
 
         public LuResult<TDboRead> AddDbo(TDboCreate obj)
             {
                 return res.To<TDboRead>();
             }
-            return NextCrud.AddDbo(res.Data);
+            return DataAccess.AddDbo(res.Data);
         }
 
 
 
         public LuResult<TDboRead> GetSingleById(string id)
         {
-            return NextCrud.GetSingleById(id);
+            return DataAccess.GetSingleById(id);
         }
 
         public LuResult<TDboRead> GetSingleById(long id)
         {
-            return NextCrud.GetSingleById(id);
+            return DataAccess.GetSingleById(id);
         }
 
         public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
         {
-            return NextCrud.GetMultiple(orderBy, 0, perPage);
+            return DataAccess.GetMultiple(orderBy, 0, perPage);
         }
 
 
             {
                 return obj.To<T>();
             }
-            return NextCrud.EditSingleById(id, obj.Data, returnFunc);
+            return DataAccess.EditSingleById(id, obj.Data, returnFunc);
         }
 
         public LuResult<long> EditSingleByIdId(long id, TDboUpdate update)
             {
                 return obj.To<long>();
             }
-            return NextCrud.EditSingleByIdId(id, obj.Data);
+            return DataAccess.EditSingleByIdId(id, obj.Data);
         }
 
         public LuResult<TDboRead> EditSingleByIdDbo(long id, TDboUpdate update)
             {
                 return obj.To<TDboRead>();
             }
-            return NextCrud.EditSingleByIdDbo(id, obj.Data);
+            return DataAccess.EditSingleByIdDbo(id, obj.Data);
         }
 
         public LuResult<T> EditSingleById<T>(string id, TDboUpdate update, Func<TDboRead, T> returnFunc)
             {
                 return obj.To<T>();
             }
-            return NextCrud.EditSingleById(id, obj.Data, returnFunc);
+            return DataAccess.EditSingleById(id, obj.Data, returnFunc);
         }
 
         public LuResult<string> EditSingleByIdGuid(string id, TDboUpdate update)
             {
                 return obj.To<string>();
             }
-            return NextCrud.EditSingleByIdGuid(id, obj.Data);
+            return DataAccess.EditSingleByIdGuid(id, obj.Data);
         }
 
         public LuResult<TDboRead> EditSingleByIdDbo(string id, TDboUpdate update)
             {
                 return obj.To<TDboRead>();
             }
-            return NextCrud.EditSingleByIdDbo(id, obj.Data);
+            return DataAccess.EditSingleByIdDbo(id, obj.Data);
         }
 
 
 
         public LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc)
         {
-            return NextCrud.DeleteSingleById(id, returnFunc);
+            return DataAccess.DeleteSingleById(id, returnFunc);
         }
 
         public LuResult<string> DeleteSingleByIdGuid(string id)
         {
-            return NextCrud.DeleteSingleByIdGuid(id);
+            return DataAccess.DeleteSingleByIdGuid(id);
         }
 
         public LuResult<TDboRead> DeleteSingleByIdDbo(string id)
         {
-            return NextCrud.DeleteSingleByIdDbo(id);
+            return DataAccess.DeleteSingleByIdDbo(id);
         }
 
         public LuResult<T> DeleteSingleById<T>(long id, Func<TDboRead, T> returnFunc)
         {
-            return NextCrud.DeleteSingleById(id, returnFunc);
+            return DataAccess.DeleteSingleById(id, returnFunc);
         }
 
         public LuResult<long> DeleteSingleByIdId(long id)
         {
-            return NextCrud.DeleteSingleByIdId(id);
+            return DataAccess.DeleteSingleByIdId(id);
         }
 
         public LuResult<TDboRead> DeleteSingleByIdDbo(long id)
         {
-            return NextCrud.DeleteSingleByIdDbo(id);
+            return DataAccess.DeleteSingleByIdDbo(id);
         }
     }
 }

Luticate2.Utils/Controllers/LuCrudController.cs

+using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Luticate2.Utils.Controllers
+{
+    public abstract class LuCrudController<TDboCreate, TDboRead, TDboUpdate> : LuController
+        where TDboCreate : class
+        where TDboRead : class
+        where TDboUpdate : class
+    {
+        protected readonly ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate> Busines;
+
+        protected LuCrudController(ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate> busines)
+        {
+            Busines = busines;
+        }
+
+        [HttpGet]
+        [Route("[controller]/{id}")]
+        public TDboRead GetSingleById(string id)
+        {
+            return Handle(Busines.GetSingleById(id));
+        }
+
+        [HttpGet]
+        [Route("[controller]")]
+        public LuPaginatedDbo<TDboRead> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        {
+            return Handle(Busines.GetMultiple(orderBy, page, perPage));
+        }
+
+        [HttpPost]
+        [Route("[controller]")]
+        public TDboRead Add([FromBody]TDboCreate data)
+        {
+            return Handle(Busines.AddDbo(data));
+        }
+
+        [HttpPost]
+        [Route("[controller]/{id}")]
+        public TDboRead Edit(string id, [FromBody]TDboUpdate data)
+        {
+            return Handle(Busines.EditSingleByIdDbo(id, data));
+        }
+
+        [HttpDelete]
+        [Route("[controller]/{id}")]
+        public TDboRead Delete(string id)
+        {
+            return Handle(Busines.DeleteSingleByIdDbo(id));
+        }
+    }
+}

WebTest/Business/PkGuidBusiness.cs

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

WebTest/Controllers/PkGuidController.cs

 using Luticate2.Utils.Controllers;
-using Luticate2.Utils.Dbo;
-using Luticate2.Utils.Dbo.OrderBy;
-using Microsoft.AspNetCore.Mvc;
 using Test.Utils.Dbo.PkGuid;
 using WebTest.Business;
 
 namespace WebTest.Controllers
 {
-    public class PkGuidController : LuController
+    public class PkGuidController : LuCrudController<PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo>
     {
-        private readonly PkGuidBusiness _busines;
-
-        public PkGuidController(PkGuidBusiness busines)
-        {
-            _busines = busines;
-        }
-
-        [HttpGet]
-        [Route("[controller]/{id}")]
-        public PkGuidDbo GetSingleById(string id)
-        {
-            return Handle(_busines.GetSingleById(id));
-        }
-
-        [HttpGet]
-        [Route("[controller]")]
-        public LuPaginatedDbo<PkGuidDbo> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
-        {
-            return Handle(_busines.GetMultiple(orderBy, page, perPage));
-        }
-
-        [HttpPost]
-        [Route("[controller]")]
-        public PkGuidDbo Add([FromBody]PkGuidAddDbo data)
-        {
-            return Handle(_busines.AddDbo(data));
-        }
-
-        [HttpPost]
-        [Route("[controller]/{id}")]
-        public PkGuidDbo Edit(string id, [FromBody]PkGuidAddDbo data)
-        {
-            return Handle(_busines.EditSingleByIdDbo(id, data));
-        }
-
-        [HttpDelete]
-        [Route("[controller]/{id}")]
-        public PkGuidDbo Delete(string id)
+        public PkGuidController(PkGuidBusiness busines) : base(busines)
         {
-            return Handle(_busines.DeleteSingleByIdDbo(id));
         }
     }
 }