generifyed long/string id; begin websockets

Luticate2.Utils/Business/LuCrudBusiness.cs

 
 namespace Luticate2.Utils.Business
 {
-    public abstract class LuCrudBusiness<TDataAccess, TDboCreate, TDboRead, TDboUpdate> : LuBusiness, ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
-        where TDataAccess : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
+    public abstract class LuCrudBusiness<TDataAccess, TDboCreate, TDboRead, TDboUpdate, TId> :
+            LuBusiness,
+            ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
+        where TDataAccess : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
         where TDboCreate : class
         where TDboRead : class
         where TDboUpdate : class
             return LuResult<TDboUpdate>.Ok(update);
         }
 
-        protected LuResult<TDboUpdate> GetAndCheckEdit(string id, TDboUpdate update)
+        protected LuResult<TDboUpdate> GetAndCheckEdit(TId id, TDboUpdate update)
         {
             var res = GetSingleById(id);
             if (!res)
             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)
+        public virtual LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
         {
             var res = CheckAdd(objs);
             if (!res)
             return DataAccess.Add(res.Data, returnFunc);
         }
 
-        public LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
+        public virtual LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
         {
             var res = CheckAdd(obj);
             if (!res)
             return DataAccess.Add(res.Data, returnFunc);
         }
 
-        public LuResult<IEnumerable<string>> AddGuid(IEnumerable<TDboCreate> objs)
+        public virtual LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs)
         {
             var res = CheckAdd(objs);
             if (!res)
             {
-                return res.To<IEnumerable<string>>();
-            }
-            return DataAccess.AddGuid(res.Data);
-        }
-
-        public LuResult<string> AddGuid(TDboCreate obj)
-        {
-            var res = CheckAdd(obj);
-            if (!res)
-            {
-                return res.To<string>();
-            }
-            return DataAccess.AddGuid(res.Data);
-        }
-
-        public LuResult<IEnumerable<long>> AddId(IEnumerable<TDboCreate> obj)
-        {
-            var res = CheckAdd(obj);
-            if (!res)
-            {
-                return res.To<IEnumerable<long>>();
+                return res.To<IEnumerable<TId>>();
             }
             return DataAccess.AddId(res.Data);
         }
 
-        public LuResult<long> AddId(TDboCreate obj)
+        public virtual LuResult<TId> AddId(TDboCreate obj)
         {
             var res = CheckAdd(obj);
             if (!res)
             {
-                return res.To<long>();
+                return res.To<TId>();
             }
             return DataAccess.AddId(res.Data);
         }
 
-        public LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
+        public virtual LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
         {
             var res = CheckAdd(obj);
             if (!res)
             return DataAccess.AddDbo(res.Data);
         }
 
-        public LuResult<TDboRead> AddDbo(TDboCreate obj)
+        public virtual LuResult<TDboRead> AddDbo(TDboCreate obj)
         {
             var res = CheckAdd(obj);
             if (!res)
 
 
 
-        public LuResult<TDboRead> GetSingleById(string id)
+        public virtual LuResult<TDboRead> GetSingleById(TId id)
         {
             return DataAccess.GetSingleById(id);
         }
 
-        public LuResult<TDboRead> GetSingleById(long id)
-        {
-            return DataAccess.GetSingleById(id);
-        }
 
-
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
             int page = 0, int perPage = int.MaxValue)
         {
             return DataAccess.GetMultiple(orderBy, filter, page, perPage);
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0,
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0,
             int perPage = int.MaxValue)
         {
             return DataAccess.GetMultiple(orderBy, page, perPage);
 
 
 
-        public LuResult<T> EditSingleById<T>(long id, TDboUpdate update, Func<TDboRead, T> returnFunc)
+        public virtual LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
         {
             var obj = GetAndCheckEdit(id, update);
             if (!obj)
             return DataAccess.EditSingleById(id, obj.Data, returnFunc);
         }
 
-        public LuResult<long> EditSingleByIdId(long id, TDboUpdate update)
+        public virtual LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
         {
             var obj = GetAndCheckEdit(id, update);
             if (!obj)
             {
-                return obj.To<long>();
+                return obj.To<TId>();
             }
-            return DataAccess.EditSingleByIdId(id, obj.Data);
+            return EditSingleById(id, obj.Data, read => (TId)((dynamic)read).Id);
         }
 
-        public LuResult<TDboRead> EditSingleByIdDbo(long id, TDboUpdate update)
+        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
         {
             var obj = GetAndCheckEdit(id, update);
             if (!obj)
             {
                 return obj.To<TDboRead>();
             }
-            return DataAccess.EditSingleByIdDbo(id, obj.Data);
+            return EditSingleById(id, obj.Data, read => read);
         }
 
-        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 DataAccess.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 DataAccess.EditSingleByIdGuid(id, obj.Data);
-        }
-
-        public LuResult<TDboRead> EditSingleByIdDbo(string id, TDboUpdate update)
-        {
-            var obj = GetAndCheckEdit(id, update);
-            if (!obj)
-            {
-                return obj.To<TDboRead>();
-            }
-            return DataAccess.EditSingleByIdDbo(id, obj.Data);
-        }
 
 
 
-
-        public LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc)
-        {
-            return DataAccess.DeleteSingleById(id, returnFunc);
-        }
-
-        public LuResult<string> DeleteSingleByIdGuid(string id)
-        {
-            return DataAccess.DeleteSingleByIdGuid(id);
-        }
-
-        public LuResult<TDboRead> DeleteSingleByIdDbo(string id)
-        {
-            return DataAccess.DeleteSingleByIdDbo(id);
-        }
-
-        public LuResult<T> DeleteSingleById<T>(long id, Func<TDboRead, T> returnFunc)
+        public virtual LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc)
         {
             return DataAccess.DeleteSingleById(id, returnFunc);
         }
 
-        public LuResult<long> DeleteSingleByIdId(long id)
+        public virtual LuResult<TId> DeleteSingleByIdId(TId id)
         {
-            return DataAccess.DeleteSingleByIdId(id);
+            return DeleteSingleById(id, read => (TId)((dynamic)read).Id);
         }
 
-        public LuResult<TDboRead> DeleteSingleByIdDbo(long id)
+        public virtual LuResult<TDboRead> DeleteSingleByIdDbo(TId id)
         {
-            return DataAccess.DeleteSingleByIdDbo(id);
+            return DeleteSingleById(id, read => read);
         }
     }
 }

Luticate2.Utils/Business/NotificationsBusiness.cs

+using Luticate2.Utils.Hubs;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.AspNetCore.SignalR.Infrastructure;
+
+namespace Luticate2.Utils.Business
+{
+    public class LuNotificationsBusiness
+    {
+        private readonly IHubContext _hubContext;
+
+        public LuNotificationsBusiness(IConnectionManager connectionManager)
+        {
+            _hubContext = connectionManager.GetHubContext<LuNotificationsHub>();
+        }
+
+        public void Notify(string eventName, string entityType, object entity)
+        {
+            _hubContext.Clients.All.notify(eventName, entityType, entity);
+        }
+
+        public void NotifyUpdate(string eventName, string entityType, object entity)
+        {
+            Notify("update", entityType, entity);
+        }
+    }
+}

Luticate2.Utils/Controllers/LuCrudController.cs

 
 namespace Luticate2.Utils.Controllers
 {
-    public abstract class LuCrudController<TBusiness, TDboCreate, TDboRead, TDboUpdate> : LuController
+    public abstract class LuCrudController<TBusiness, TDboCreate, TDboRead, TDboUpdate, TId> : LuController
         where TDboCreate : class
         where TDboRead : class
         where TDboUpdate : class
-        where TBusiness : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
+        where TBusiness : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
     {
         protected readonly TBusiness Busines;
 
 
         [HttpGet]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> GetSingleById(string id)
+        public LuApiWrapperDbo<TDboRead> GetSingleById(TId id)
         {
             return Handle(Busines.GetSingleById(id));
         }
 
         [HttpPost]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> EditSingleByIdDbo(string id, [FromBody]TDboUpdate data)
+        public LuApiWrapperDbo<TDboRead> EditSingleByIdDbo(TId id, [FromBody]TDboUpdate data)
         {
             return Handle(Busines.EditSingleByIdDbo(id, data));
         }
 
         [HttpDelete]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> Delete(string id)
+        public LuApiWrapperDbo<TDboRead> Delete(TId id)
         {
             return Handle(Busines.DeleteSingleByIdDbo(id));
         }

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

 using System.Collections.Generic;
+using Luticate2.Utils.Business;
 using Luticate2.Utils.DataAccess.Npgsql;
 using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.Filter;
 
         public static IServiceCollection AddLuticateUtils(this IServiceCollection services, LuOptionsDelegate optionsDelegate)
         {
+            services.AddSingleton<LuNotificationsBusiness>();
             Options = new LuOptionsDbo();
             optionsDelegate(Options);
+            services.AddSignalR(options =>
+            {
+                options.Hubs.EnableDetailedErrors = true;
+            });
             return services;
         }
 
         public static IApplicationBuilder UseLuticateUtils(this IApplicationBuilder app)
         {
             app.UseMiddleware<LuExceptionMiddleware>();
+
+            app.UseWebSockets();
+            app.UseSignalR();
+
             return app;
         }
 

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using Luticate2.Utils.DataAccess.Npgsql;
 using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Interfaces;
 using Luticate2.Utils.Utils;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 
 namespace Luticate2.Utils.DataAccess
 {
-    public abstract class LuEfCrudDataAccess<TModel, TDboCreate, TDboRead, TDboUpdate, TDbContext> :
-            LuEfDataAccess<TModel, TDbContext>, ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
+    public abstract class LuEfCrudDataAccess<TModel, TDboCreate, TDboRead, TDboUpdate, TDbContext, TId> :
+            LuEfDataAccess<TModel, TDbContext>,
+            ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
         where TModel : class
         where TDboCreate : class
         where TDboRead : class
             return model;
         }
 
-        protected Guid? GetGuid(string id)
+        protected virtual object GetId(TId id)
         {
-            Guid guid;
-            if (Guid.TryParse(id, out guid))
+            var s = id as string;
+            if (s != null)
             {
-                return guid;
+                Guid guid;
+                if (Guid.TryParse(s, out guid))
+                {
+                    return guid;
+                }
+                return null;
+
             }
-            return null;
+            return id;
         }
 
         protected LuResult<T> GetNotFoundResult<T>()
         }
 
 
-        public LuResult<IEnumerable<string>> AddGuid(IEnumerable<TDboCreate> objs)
+        public LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs)
         {
-            var func = GetIdFunc<string>();
+            var func = GetIdFunc<TId>();
             return Add(objs, list => list.Select(func));
         }
 
-        public LuResult<string> AddGuid(TDboCreate obj)
-        {
-            return AddGuid(new List<TDboCreate> {obj}).To(list => list.First());
-        }
-
-
-        public LuResult<IEnumerable<long>> AddId(IEnumerable<TDboCreate> obj)
-        {
-            var func = GetIdFunc<long>();
-            return Add(obj, list => list.Select(func));
-        }
-
-        public LuResult<long> AddId(TDboCreate obj)
+        public LuResult<TId> AddId(TDboCreate obj)
         {
             return AddId(new List<TDboCreate> {obj}).To(list => list.First());
         }
             return GetSingle(GetExpression(keys));
         }
 
-        public LuResult<TDboRead> GetSingleById(string id)
+        public LuResult<TDboRead> GetSingleById(TId id)
         {
-            var guid = GetGuid(id);
+            var guid = GetId(id);
             if (guid == null)
             {
                 return GetNotFoundResult<TDboRead>();
             return GetSingleByKeys(new KeyValuePair<string, object>("id", guid));
         }
 
-        public LuResult<TDboRead> GetSingleById(long id)
-        {
-            return GetSingleByKeys(new KeyValuePair<string, object>("id", id));
-        }
-
 
         public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<DbSet<TModel>, IOrderedQueryable<TModel>> orderBy,
             Expression<Func<TModel, bool>> predicate, int page = 0, int perPage = int.MaxValue,
             return GetMultiple(orderBy, x => true, page, perPage, otherOrderBy);
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, IQueryable<TModel> queryable,
             int page = 0, int perPage = int.MaxValue)
         {
             return Execute(() =>
             {
-                var queryable = GetFilterQuery(filter);
                 var count = queryable.Count();
                 IOrderedQueryable<TModel> ordered = null;
                 foreach (var field in orderBy.Fields)
             });
         }
 
+        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+            int page = 0, int perPage = int.MaxValue)
+        {
+            return GetMultiple(orderBy, GetFilterQuery(filter), page, perPage);
+        }
+
         public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
         {
-            var filter = new LuFilterDbo
-            {
-                Query = ""
-            };
-            return GetMultiple(orderBy, filter, page, perPage);
+            return GetMultiple(orderBy, Table, page, perPage);
         }
 
 
             });
         }
 
-        public LuResult<IEnumerable<string>> EditGuid(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
-        {
-            var func = GetIdFunc<string>();
-            return Edit(predicate, update, reads => reads.Select(func));
-        }
-
-        public LuResult<IEnumerable<long>> EditId(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
+        public LuResult<IEnumerable<TId>> EditId(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
         {
-            var func = GetIdFunc<long>();
+            var func = GetIdFunc<TId>();
             return Edit(predicate, update, reads => reads.Select(func));
         }
 
         }
 
 
-        public LuResult<T> EditSingleById<T>(long id, Action<TModel> update, Func<TDboRead, T> returnFunc)
+        public LuResult<T> EditSingleById<T>(TId id, Action<TModel> update, Func<TDboRead, T> returnFunc)
         {
-            return Edit(GetExpression(new KeyValuePair<string, object>("id", id)), update,
-                list => returnFunc(list.FirstOrDefault()));
-        }
-
-        public LuResult<long> EditSingleByIdId(long id, Action<TModel> update)
-        {
-            var func = GetIdFunc<long>();
-            return EditSingleById(id, update, func);
-        }
-
-        public LuResult<TDboRead> EditSingleByIdDbo(long id, Action<TModel> update)
-        {
-            return EditSingleById(id, update, read => read);
-        }
-
-
-        public LuResult<T> EditSingleById<T>(string id, Action<TModel> update, Func<TDboRead, T> returnFunc)
-        {
-            var guid = GetGuid(id);
+            var guid = GetId(id);
             if (guid == null)
             {
                 return GetNotFoundResult<T>();
                 list => returnFunc(list.FirstOrDefault()));
         }
 
-        public LuResult<string> EditSingleByIdGuid(string id, Action<TModel> update)
-        {
-            return EditSingleById(id, update, GetIdFunc<string>());
-        }
-
-        public LuResult<TDboRead> EditSingleByIdDbo(string id, Action<TModel> update)
-        {
-            return EditSingleById(id, update, read => read);
-        }
-
-
-        public LuResult<T> EditSingleById<T>(long id, TDboUpdate update, Func<TDboRead, T> returnFunc)
-        {
-            return Edit(GetExpression(new KeyValuePair<string, object>("id", id)),
-                model => EditModelFromTUpdate(update, model), list => returnFunc(list.FirstOrDefault()));
-        }
-
-        public LuResult<long> EditSingleByIdId(long id, TDboUpdate update)
+        public LuResult<TId> EditSingleByIdId(TId id, Action<TModel> update)
         {
-            return EditSingleById(id, update, GetIdFunc<long>());
+            return EditSingleById(id, update, GetIdFunc<TId>());
         }
 
-        public LuResult<TDboRead> EditSingleByIdDbo(long id, TDboUpdate update)
+        public LuResult<TDboRead> EditSingleByIdDbo(TId id, Action<TModel> update)
         {
             return EditSingleById(id, update, read => read);
         }
 
 
-        public LuResult<T> EditSingleById<T>(string id, TDboUpdate update, Func<TDboRead, T> returnFunc)
+        public LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
         {
-            var guid = GetGuid(id);
+            var guid = GetId(id);
             if (guid == null)
             {
                 return GetNotFoundResult<T>();
                 model => EditModelFromTUpdate(update, model), list => returnFunc(list.FirstOrDefault()));
         }
 
-        public LuResult<string> EditSingleByIdGuid(string id, TDboUpdate update)
+        public LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
         {
-            return EditSingleById(id, update, GetIdFunc<string>());
+            return EditSingleById(id, update, GetIdFunc<TId>());
         }
 
-        public LuResult<TDboRead> EditSingleByIdDbo(string id, TDboUpdate update)
+        public LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
         {
             return EditSingleById(id, update, read => read);
         }
             });
         }
 
-        public LuResult<IEnumerable<string>> DeleteGuid(Expression<Func<TModel, bool>> predicate)
+        public LuResult<IEnumerable<TId>> DeleteId(Expression<Func<TModel, bool>> predicate)
         {
-            var func = GetIdFunc<string>();
-            return Delete(predicate, reads => reads.Select(func));
-        }
-
-        public LuResult<IEnumerable<long>> DeleteId(Expression<Func<TModel, bool>> predicate)
-        {
-            var func = GetIdFunc<long>();
+            var func = GetIdFunc<TId>();
             return Delete(predicate, reads => reads.Select(func));
         }
 
         }
 
 
-        public LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc)
+        public LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc)
         {
-            var guid = GetGuid(id);
+            var guid = GetId(id);
             if (guid == null)
             {
                 return GetNotFoundResult<T>();
                 reads => returnFunc(reads.FirstOrDefault()));
         }
 
-        public LuResult<string> DeleteSingleByIdGuid(string id)
-        {
-            var func = GetIdFunc<string>();
-            return DeleteSingleById(id, func);
-        }
-
-        public LuResult<TDboRead> DeleteSingleByIdDbo(string id)
-        {
-            return DeleteSingleById(id, read => read);
-        }
-
-
-        public LuResult<T> DeleteSingleById<T>(long id, Func<TDboRead, T> returnFunc)
-        {
-            return Delete(GetExpression(new KeyValuePair<string, object>("id", id)),
-                reads => returnFunc(reads.First()));
-        }
-
-        public LuResult<long> DeleteSingleByIdId(long id)
+        public LuResult<TId> DeleteSingleByIdId(TId id)
         {
-            var func = GetIdFunc<long>();
+            var func = GetIdFunc<TId>();
             return DeleteSingleById(id, func);
         }
 
-        public LuResult<TDboRead> DeleteSingleByIdDbo(long id)
+        public LuResult<TDboRead> DeleteSingleByIdDbo(TId id)
         {
             return DeleteSingleById(id, read => read);
         }

Luticate2.Utils/Hubs/LuNotificationsHub.cs

+using Microsoft.AspNetCore.SignalR;
+
+namespace Luticate2.Utils.Hubs
+{
+    public class LuNotificationsHub : Hub
+    {
+
+    }
+}

Luticate2.Utils/Interfaces/ILuCrudInterface.cs

 
 namespace Luticate2.Utils.Interfaces
 {
-    public interface ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
+    public interface ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
         where TDboCreate : class
         where TDboRead : class
         where TDboUpdate : class
         LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc);
 
 
-        LuResult<IEnumerable<string>> AddGuid(IEnumerable<TDboCreate> objs);
+        LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs);
 
-        LuResult<string> AddGuid(TDboCreate obj);
-
-
-        LuResult<IEnumerable<long>> AddId(IEnumerable<TDboCreate> obj);
-
-        LuResult<long> AddId(TDboCreate obj);
+        LuResult<TId> AddId(TDboCreate obj);
 
         LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj);
 
 
 
 
-        LuResult<TDboRead> GetSingleById(string id);
-
-        LuResult<TDboRead> GetSingleById(long id);
+        LuResult<TDboRead> GetSingleById(TId id);
 
 
         LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
 
 
 
-        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> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc);
 
+        LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update);
 
-        LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc);
+        LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update);
 
-        LuResult<string> DeleteSingleByIdGuid(string id);
 
-        LuResult<TDboRead> DeleteSingleByIdDbo(string id);
 
 
-        LuResult<T> DeleteSingleById<T>(long id, Func<TDboRead, T> returnFunc);
+        LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc);
 
-        LuResult<long> DeleteSingleByIdId(long id);
+        LuResult<TId> DeleteSingleByIdId(TId id);
 
-        LuResult<TDboRead> DeleteSingleByIdDbo(long id);
+        LuResult<TDboRead> DeleteSingleByIdDbo(TId id);
     }
 }

TODO

-fix crud business checks
 websockets
 authentication filter
-filter dbo
-try to generify long/string id
 logs
 log exceptions in middleware
 LuCrudBusiness check user?

Test/Utils/DataAccess/LuUtilsPkBigSerialDataAccess.cs

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

Test/Utils/DataAccess/LuUtilsPkGuidDataAccess.cs

 using System.Linq.Expressions;
 using Luticate2.Utils.DataAccess;
 using Luticate2.Utils.Dbo.Filter;
-using Luticate2.Utils.Utils;
 using Test.Utils.DataAccess.Models;
 using Test.Utils.Dbo.PkGuid;
 
 namespace Test.Utils.DataAccess
 {
-    public class LuUtilsPkGuidDataAccess : LuEfCrudDataAccess<pk_guid, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, LuUtilsDbContext>
+    public class LuUtilsPkGuidDataAccess : LuEfCrudDataAccess<pk_guid, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, LuUtilsDbContext, string>
     {
         public LuUtilsPkGuidDataAccess(LuUtilsDbContext db) : base(db, db.pk_guid)
         {

Test/Utils/EfCrudDataAccess/LuEfCreateDataAccessTest.cs

                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
                 foreach (var dbo in dbos.Zip(res.Data, (dbo, serialDbo) => new KeyValuePair<PkGuidAddDbo, string>(dbo, serialDbo)))
                 {
             Tests.TestRealDb(context =>
             {
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(new PkGuidAddDbo
+                var res = service.AddId(new PkGuidAddDbo
                 {
                     SomeInt = 42,
                     SomeText = "42"

Test/Utils/EfCrudDataAccess/LuEfDeleteDataAccessTest.cs

-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
-using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.Result;
 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 LuEfDeleteDataAccessTest
     {
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var edit = service.Delete(guid => guid.some_int == 42, enumerable => enumerable);
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var edit = service.Delete(guid => guid.some_int == 42, enumerable => enumerable.Select(guidDbo => guidDbo.Id));
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
-                var edit = service.DeleteGuid(guid => guid.some_int == 42);
+                var edit = service.DeleteId(guid => guid.some_int == 42);
 
                 Assert.Equal(LuStatus.Success, edit.Status);
                 var elements = edit.Data.ToList();
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var edit = service.DeleteDbo(guid => guid.some_int == 42);
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var ids = res.Data.ToList();
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var ids = res.Data.ToList();
 
-                var edit = service.DeleteSingleByIdGuid(ids[0]);
+                var edit = service.DeleteSingleByIdId(ids[0]);
                 Assert.Equal(LuStatus.Success, edit.Status);
 
                 var get = service.GetMultiple(guid => guid.some_text);
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var ids = res.Data.ToList();

Test/Utils/EfCrudDataAccess/LuEfReadDataAccessTest.cs

             Tests.TestRealDb(context =>
             {
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(new PkGuidAddDbo
+                var res = service.AddId(new PkGuidAddDbo
                 {
                     SomeInt = 42,
                     SomeText = "42"
             Tests.TestRealDb(context =>
             {
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(new PkGuidAddDbo
+                var res = service.AddId(new PkGuidAddDbo
                 {
                     SomeInt = 42,
                     SomeText = "42"
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var get = service.GetMultiple(table => table.OrderBy(guid => guid.some_int),
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var get = service.GetMultiple(guid => guid.some_int, guid => guid.some_int == 42, 0, int.MaxValue,
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var get = service.GetMultiple(table => table.OrderBy(guid => guid.some_int), 0, int.MaxValue,
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var get = service.GetMultiple(guid => guid.some_int, 0, int.MaxValue, guid => guid.some_text);
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var orderBy = LuOrderByBinder.FromString("someInt,someText");
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var orderBy = LuOrderByBinder.FromString("someText:desc,someInt");

Test/Utils/EfCrudDataAccess/LuEfUpdateDataAccessTest.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.Result;
 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 LuEfUpdateDataAccessTest
     {
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var edit = service.Edit(guid => guid.some_int == 42, guid => guid.some_int = -1, enumerable => enumerable);
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var edit = service.Edit(guid => guid.some_int == 42, guid => guid.some_int = -1, enumerable => enumerable.Select(guidDbo => guidDbo.SomeText));
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
-                var edit = service.EditGuid(guid => guid.some_int == 42, guid => guid.some_int = -1);
+                var edit = service.EditId(guid => guid.some_int == 42, guid => guid.some_int = -1);
 
                 Assert.Equal(LuStatus.Success, edit.Status);
                 var elements = edit.Data.ToList();
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
 
                 var edit = service.EditDbo(guid => guid.some_int == 42, guid => guid.some_int = -1);
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
                 var ids = res.Data.ToList();
 
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
                 var ids = res.Data.ToList();
 
-                var edit = service.EditSingleByIdGuid(ids[0], guid => guid.some_int = -1);
+                var edit = service.EditSingleByIdId(ids[0], guid => guid.some_int = -1);
                 Assert.Equal(LuStatus.Success, edit.Status);
 
                 var get = service.GetMultiple(guid => guid.some_text);
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
                 var ids = res.Data.ToList();
 
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
                 var ids = res.Data.ToList();
 
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
                 var ids = res.Data.ToList();
 
                 dbos[0].SomeInt = -1;
 
-                var edit = service.EditSingleByIdGuid(ids[0], dbos[0]);
+                var edit = service.EditSingleByIdId(ids[0], dbos[0]);
                 Assert.Equal(LuStatus.Success, edit.Status);
 
                 var get = service.GetMultiple(guid => guid.some_text);
                     }
                 };
                 var service = new LuUtilsPkGuidDataAccess(context);
-                var res = service.AddGuid(dbos);
+                var res = service.AddId(dbos);
                 Assert.Equal(LuStatus.Success, res.Status);
                 var ids = res.Data.ToList();
 

WebTest/Business/PkGuidBusiness.cs

 
 namespace WebTest.Business
 {
-    public class PkGuidBusiness : LuCrudBusiness<LuUtilsPkGuidDataAccess, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo>
+    public class PkGuidBusiness : LuCrudBusiness<LuUtilsPkGuidDataAccess, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, string>
     {
-        public PkGuidBusiness(LuUtilsPkGuidDataAccess dataAccess) : base(dataAccess)
+        private readonly LuNotificationsBusiness _notificationsBusiness;
+
+        public PkGuidBusiness(LuUtilsPkGuidDataAccess dataAccess, LuNotificationsBusiness notificationsBusiness) : base(dataAccess)
         {
+            _notificationsBusiness = notificationsBusiness;
         }
 
         protected override LuResult<PkGuidAddDbo> CheckAdd(PkGuidAddDbo obj)
             }
             return LuResult<PkGuidAddDbo>.Ok(update);
         }
+
+
     }
 }

WebTest/Controllers/PkGuidController.cs

 
 namespace WebTest.Controllers
 {
-    public class PkGuidController : LuCrudController<PkGuidBusiness, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo>
+    public class PkGuidController : LuCrudController<PkGuidBusiness, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, string>
     {
         public PkGuidController(PkGuidBusiness busines) : base(busines)
         {