added crud interface; tests; lubusiness; lucontroller

Luticate2.Utils/Business/LuBusiness.cs

@@ -2,6 +2,5 @@
 {
     public abstract class LuBusiness
     {
-
     }
 }

Luticate2.Utils/Business/LuCrudBusiness.cs

@@ -0,0 +1,262 @@
+using System;
+using System.Collections.Generic;
+using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Interfaces;
+
+namespace Luticate2.Utils.Business
+{
+    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 TDataAccess Db;
+
+        protected LuCrudBusiness(TDataAccess db)
+        {
+            Db = db;
+        }
+
+        protected virtual LuResult<TDboCreate> CheckAdd(TDboCreate obj)
+        {
+            return LuResult<TDboCreate>.Ok(obj);
+        }
+
+        protected virtual LuResult<IEnumerable<TDboCreate>> CheckAdd(IEnumerable<TDboCreate> objs)
+        {
+            var list = new List<TDboCreate>();
+            foreach (var obj in objs)
+            {
+                var res = CheckAdd(obj);
+                if (!res)
+                {
+                    return res.To<IEnumerable<TDboCreate>>();
+                }
+                list.Add(res.Data);
+            }
+            return LuResult<IEnumerable<TDboCreate>>.Ok(list);
+        }
+
+        protected virtual LuResult<TDboUpdate> CheckEdit(TDboRead dbo, TDboUpdate update)
+        {
+            return LuResult<TDboUpdate>.Ok(update);
+        }
+
+        protected LuResult<TDboUpdate> GetAndCheckEdit(string id, TDboUpdate update)
+        {
+            var res = GetSingleById(id);
+            if (!res)
+            {
+                return res.To<TDboUpdate>();
+            }
+            return CheckEdit(res.Data, update);
+        }
+
+        protected LuResult<TDboUpdate> GetAndCheckEdit(long id, TDboUpdate update)
+        {
+            var res = GetSingleById(id);
+            if (!res)
+            {
+                return res.To<TDboUpdate>();
+            }
+            return CheckEdit(res.Data, update);
+        }
+
+
+
+        public LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
+        {
+            var res = CheckAdd(objs);
+            if (!res)
+            {
+                return res.To<T>();
+            }
+            return Db.Add(res.Data, returnFunc);
+        }
+
+        public LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
+        {
+            var res = CheckAdd(obj);
+            if (!res)
+            {
+                return res.To<T>();
+            }
+            return Db.Add(res.Data, returnFunc);
+        }
+
+        public LuResult<IEnumerable<string>> AddGuid(IEnumerable<TDboCreate> objs)
+        {
+            var res = CheckAdd(objs);
+            if (!res)
+            {
+                return res.To<IEnumerable<string>>();
+            }
+            return Db.AddGuid(res.Data);
+        }
+
+        public LuResult<string> AddGuid(TDboCreate obj)
+        {
+            var res = CheckAdd(obj);
+            if (!res)
+            {
+                return res.To<string>();
+            }
+            return Db.AddGuid(res.Data);
+        }
+
+        public LuResult<IEnumerable<long>> AddId(IEnumerable<TDboCreate> obj)
+        {
+            var res = CheckAdd(obj);
+            if (!res)
+            {
+                return res.To<IEnumerable<long>>();
+            }
+            return Db.AddId(res.Data);
+        }
+
+        public LuResult<long> AddId(TDboCreate obj)
+        {
+            var res = CheckAdd(obj);
+            if (!res)
+            {
+                return res.To<long>();
+            }
+            return Db.AddId(res.Data);
+        }
+
+        public LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
+        {
+            var res = CheckAdd(obj);
+            if (!res)
+            {
+                return res.To<IEnumerable<TDboRead>>();
+            }
+            return Db.AddDbo(res.Data);
+        }
+
+        public LuResult<TDboRead> AddDbo(TDboCreate obj)
+        {
+            var res = CheckAdd(obj);
+            if (!res)
+            {
+                return res.To<TDboRead>();
+            }
+            return Db.AddDbo(res.Data);
+        }
+
+
+
+
+        public LuResult<TDboRead> GetSingleByKeys(params KeyValuePair<string, object>[] keys)
+        {
+            return Db.GetSingleByKeys(keys);
+        }
+
+        public LuResult<TDboRead> GetSingleById(string id)
+        {
+            return Db.GetSingleById(id);
+        }
+
+        public LuResult<TDboRead> GetSingleById(long id)
+        {
+            return Db.GetSingleById(id);
+        }
+
+
+
+
+        public LuResult<T> EditSingleById<T>(long id, TDboUpdate update, Func<TDboRead, T> returnFunc)
+        {
+            var obj = GetAndCheckEdit(id, update);
+            if (!obj)
+            {
+                return obj.To<T>();
+            }
+            return Db.EditSingleById(id, obj.Data, returnFunc);
+        }
+
+        public LuResult<long> EditSingleByIdId(long id, TDboUpdate update)
+        {
+            var obj = GetAndCheckEdit(id, update);
+            if (!obj)
+            {
+                return obj.To<long>();
+            }
+            return Db.EditSingleByIdId(id, obj.Data);
+        }
+
+        public LuResult<TDboRead> EditSingleByIdDbo(long id, TDboUpdate update)
+        {
+            var obj = GetAndCheckEdit(id, update);
+            if (!obj)
+            {
+                return obj.To<TDboRead>();
+            }
+            return Db.EditSingleByIdDbo(id, obj.Data);
+        }
+
+        public LuResult<T> EditSingleById<T>(string id, TDboUpdate update, Func<TDboRead, T> returnFunc)
+        {
+            var obj = GetAndCheckEdit(id, update);
+            if (!obj)
+            {
+                return obj.To<T>();
+            }
+            return Db.EditSingleById(id, obj.Data, returnFunc);
+        }
+
+        public LuResult<string> EditSingleByIdGuid(string id, TDboUpdate update)
+        {
+            var obj = GetAndCheckEdit(id, update);
+            if (!obj)
+            {
+                return obj.To<string>();
+            }
+            return Db.EditSingleByIdGuid(id, obj.Data);
+        }
+
+        public LuResult<TDboRead> EditSingleByIdDbo(string id, TDboUpdate update)
+        {
+            var obj = GetAndCheckEdit(id, update);
+            if (!obj)
+            {
+                return obj.To<TDboRead>();
+            }
+            return Db.EditSingleByIdDbo(id, obj.Data);
+        }
+
+
+
+
+        public LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc)
+        {
+            return Db.DeleteSingleById(id, returnFunc);
+        }
+
+        public LuResult<string> DeleteSingleByIdGuid(string id)
+        {
+            return Db.DeleteSingleByIdGuid(id);
+        }
+
+        public LuResult<TDboRead> DeleteSingleByIdDbo(string id)
+        {
+            return Db.DeleteSingleByIdDbo(id);
+        }
+
+        public LuResult<T> DeleteSingleById<T>(long id, Func<TDboRead, T> returnFunc)
+        {
+            return Db.DeleteSingleById(id, returnFunc);
+        }
+
+        public LuResult<long> DeleteSingleByIdId(long id)
+        {
+            return Db.DeleteSingleByIdId(id);
+        }
+
+        public LuResult<TDboRead> DeleteSingleByIdDbo(long id)
+        {
+            return Db.DeleteSingleByIdDbo(id);
+        }
+    }
+}

Luticate2.Utils/Controllers/LuController.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using Luticate2.Utils.Dbo;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.SignalR.Infrastructure;
 
@@ -11,5 +13,14 @@ namespace Luticate2.Utils.Controllers
         protected IDictionary<object, object> LuItems => (IDictionary<object, object>) HttpContext.Items["luticateItems"];
 
 //        protected UsersDbo LuCurrentUser => (UsersDbo) LuItems["luticateItems"];
+
+        protected T Handle<T>(LuResult<T> result)
+        {
+            if (result)
+            {
+                return result.Data;
+            }
+            return default(T);//TODO
+        }
     }
 }

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

@@ -3,19 +3,20 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Interfaces;
 using Microsoft.EntityFrameworkCore;
 
 namespace Luticate2.Utils.DataAccess
 {
-    public abstract class LuEfCrudDataAccess<TModel, TDboCreate, TDboRead, TDboUpdate, TDbContext> :
-            LuEfDataAccess<TModel, TDbContext>
+    public abstract class LuEfCrudInterface<TModel, TDboCreate, TDboRead, TDboUpdate, TDbContext> :
+            LuEfDataAccess<TModel, TDbContext>, ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
         where TModel : class
         where TDboCreate : class
         where TDboRead : class
         where TDboUpdate : class
         where TDbContext : DbContext
     {
-        protected LuEfCrudDataAccess(TDbContext db, DbSet<TModel> table) : base(db, table)
+        protected LuEfCrudInterface(TDbContext db, DbSet<TModel> table) : base(db, table)
         {
         }
 

Luticate2.Utils/Interfaces/ILuCrudInterface.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using Luticate2.Utils.Dbo;
+
+namespace Luticate2.Utils.Interfaces
+{
+    public interface ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
+        where TDboCreate : class
+        where TDboRead : class
+        where TDboUpdate : class
+    {
+        LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc);
+
+        LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc);
+
+
+        LuResult<IEnumerable<string>> AddGuid(IEnumerable<TDboCreate> objs);
+
+        LuResult<string> AddGuid(TDboCreate obj);
+
+
+        LuResult<IEnumerable<long>> AddId(IEnumerable<TDboCreate> obj);
+
+        LuResult<long> AddId(TDboCreate obj);
+
+        LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj);
+
+        LuResult<TDboRead> AddDbo(TDboCreate obj);
+
+
+
+
+        LuResult<TDboRead> GetSingleByKeys(params KeyValuePair<string, object>[] keys);
+
+        LuResult<TDboRead> GetSingleById(string id);
+
+        LuResult<TDboRead> GetSingleById(long id);
+
+
+
+        LuResult<T> EditSingleById<T>(long id, TDboUpdate update, Func<TDboRead, T> returnFunc);
+
+        LuResult<long> EditSingleByIdId(long id, TDboUpdate update);
+
+        LuResult<TDboRead> EditSingleByIdDbo(long id, TDboUpdate update);
+
+
+        LuResult<T> EditSingleById<T>(string id, TDboUpdate update, Func<TDboRead, T> returnFunc);
+
+        LuResult<string> EditSingleByIdGuid(string id, TDboUpdate update);
+
+        LuResult<TDboRead> EditSingleByIdDbo(string id, TDboUpdate update);
+
+
+
+
+        LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc);
+
+        LuResult<string> DeleteSingleByIdGuid(string id);
+
+        LuResult<TDboRead> DeleteSingleByIdDbo(string id);
+
+
+        LuResult<T> DeleteSingleById<T>(long id, Func<TDboRead, T> returnFunc);
+
+        LuResult<long> DeleteSingleByIdId(long id);
+
+        LuResult<TDboRead> DeleteSingleByIdDbo(long id);
+    }
+}

Test/Utils/DataAccess/LuUtilsPkBigSerialDataAccess.cs

@@ -4,7 +4,7 @@ using Test.Utils.Dbo.PkBigSerial;
 
 namespace Test.Utils.DataAccess
 {
-    public class LuUtilsPkBigSerialDataAccess : LuEfCrudDataAccess<pk_bigserial, PkBigSerialAddDbo, PkBigSerialDbo, PkBigSerialAddDbo, LuUtilsDbContext>
+    public class LuUtilsPkBigSerialDataAccess : LuEfCrudInterface<pk_bigserial, PkBigSerialAddDbo, PkBigSerialDbo, PkBigSerialAddDbo, LuUtilsDbContext>
     {
         public LuUtilsPkBigSerialDataAccess(LuUtilsDbContext db) : base(db, db.pk_bigserial)
         {

Test/Utils/DataAccess/LuUtilsPkGuidDataAccess.cs

@@ -4,7 +4,7 @@ using Test.Utils.Dbo.PkGuid;
 
 namespace Test.Utils.DataAccess
 {
-    public class LuUtilsPkGuidDataAccess : LuEfCrudDataAccess<pk_guid, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, LuUtilsDbContext>
+    public class LuUtilsPkGuidDataAccess : LuEfCrudInterface<pk_guid, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, LuUtilsDbContext>
     {
         public LuUtilsPkGuidDataAccess(LuUtilsDbContext db) : base(db, db.pk_guid)
         {

Test/Utils/Tests.cs

@@ -1,15 +1,18 @@
 using System;
+using Castle.Core.Resource;
 using Test.Utils.DataAccess;
 
 namespace Test.Utils
 {
     public class Tests
     {
+        public const string CONNECTION_STRING =
+            "User ID=dev;Password=dev;Host=localhost;Port=5432;Database=luticate2_utils;Pooling=true;";
+
         public static LuUtilsDbContext GetDataBaseContext()
         {
             return
-                new LuUtilsDbContext(
-                    "User ID=dev;Password=dev;Host=localhost;Port=5432;Database=luticate2_utils;Pooling=true;");
+                new LuUtilsDbContext(CONNECTION_STRING);
         }
 
         public static void TestRealDb(Action<LuUtilsDbContext> func)

WebTest/Business/PkGuidBusiness.cs

@@ -0,0 +1,13 @@
+using Luticate2.Utils.Business;
+using Test.Utils.DataAccess;
+using Test.Utils.Dbo.PkGuid;
+
+namespace WebTest.Business
+{
+    public class PkGuidBusiness : LuCrudBusiness<LuUtilsPkGuidDataAccess, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo>
+    {
+        public PkGuidBusiness(LuUtilsPkGuidDataAccess db) : base(db)
+        {
+        }
+    }
+}

WebTest/Controllers/PkGuidController.cs

@@ -0,0 +1,29 @@
+using Luticate2.Utils.Controllers;
+using Microsoft.AspNetCore.Mvc;
+using Test.Utils.Dbo.PkGuid;
+using WebTest.Business;
+
+namespace WebTest.Controllers
+{
+    public class PkGuidController : LuController
+    {
+        private readonly PkGuidBusiness _busines;
+
+        public PkGuidController(PkGuidBusiness busines)
+        {
+            _busines = busines;
+        }
+
+        [Route("[controller]/{id}")]
+        public PkGuidDbo Get(string id)
+        {
+            return Handle(_busines.GetSingleById(id));
+        }
+
+//        [Route("[controller]")]
+//        public PkGuidDbo Get()
+//        {
+//            return Handle(_busines.GetMultiple());
+//        }
+    }
+}

WebTest/Startup.cs

@@ -1,9 +1,14 @@
 using Luticate2.Auth.Controllers;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Test.Utils;
+using Test.Utils.DataAccess;
+using WebTest.Business;
+using WebTest.Controllers;
 
 namespace WebTest
 {
@@ -36,6 +41,10 @@ namespace WebTest
 
             services.AddLuticate();
 
+            services.AddSingleton<PkGuidBusiness>();
+            services.AddSingleton<LuUtilsPkGuidDataAccess>();
+            services.AddDbContext<LuUtilsDbContext>(options => options.UseNpgsql(Tests.CONNECTION_STRING));
+
             services.AddMvc()
                 .AddLuticate();
 

WebTest/project.json

@@ -1,6 +1,7 @@
 {
   "dependencies": {
     "Luticate2.Auth": "1.0.*",
+    "Test": "1.0.*",
     "Microsoft.ApplicationInsights.AspNetCore": "1.0.2",
     "Microsoft.AspNetCore.Mvc": "1.1.0",
     "Microsoft.AspNetCore.Routing": "1.1.0",