refactor crud utils; added auth options dbo

Luticate2.Auth/Business/LuBusinessExtensions.cs

             };//TODO
         }
 
-        public static LuUsersToken ToUserToken(this LuTokensDbo dbo)
+        public static LuUsersTokenDbo ToUserToken(this LuTokensDbo dbo)
         {
             if (dbo == null)
             {
                 return null;
             }
-            return new LuUsersToken
+            return new LuUsersTokenDbo
             {
                 Data = dbo.Data,
                 NotAfter = dbo.NotAfter,

Luticate2.Auth/Business/LuGroupsBusiness.cs

-using Luticate2.Auth.DataAccess;
+using System;
+using Luticate2.Auth.DataAccess;
 using Luticate2.Auth.Dbo.Groups;
 using Luticate2.Auth.Interfaces.Groups;
 using Luticate2.Utils.Business;
-using Luticate2.Utils.Interfaces;
 
 namespace Luticate2.Auth.Business
 {
     public class LuGroupsBusiness : LuCrudBusiness<LuGroupsDataAccess, LuGroupsAddDbo, LuGroupsDbo, LuGroupsAddDbo, string>,
         ILuGroupsBusiness
     {
-        public LuGroupsBusiness(LuGroupsDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness) : base(dataAccess, notificationsBusiness)
+        public LuGroupsBusiness(LuGroupsDataAccess dataAccess, IServiceProvider serviceProvider) : base(dataAccess, serviceProvider)
         {
         }
     }

Luticate2.Auth/Business/LuTokensBusiness.cs

 using System;
+using System.Linq;
 using System.Security.Cryptography;
 using Luticate2.Auth.DataAccess;
 using Luticate2.Auth.Dbo.Tokens;
 using Luticate2.Auth.Dbo.Users;
 using Luticate2.Auth.Interfaces.Tokens;
 using Luticate2.Utils.Business;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Interfaces;
 using Luticate2.Utils.Utils;
     {
         private readonly IDateTime _dateTime;
 
-        public LuTokensBusiness(LuTokensDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness, IDateTime dateTime) : base(dataAccess, notificationsBusiness)
+        public LuTokensBusiness(LuTokensDataAccess dataAccess, IServiceProvider serviceProvider, IDateTime dateTime) : base(dataAccess, serviceProvider)
         {
             _dateTime = dateTime;
         }
 
-        public LuResult<LuUsersToken> GetToken(string token)
+        public LuResult<LuUsersTokenDbo> GetToken(string token)
         {
             return GetSingleById(token).To(dbo => dbo.ToUserToken());
         }
 
-        public string GenerateId()
+        public string GenerateId()//TODO
         {
             var token = new byte[50];
             using (var rng = RandomNumberGenerator.Create())
             return Convert.ToBase64String(token).Trim('=');
         }
 
-        public LuResult<string> RegisterToken(LuUsersToken token)
+        public LuResult<string> RegisterToken(LuUsersTokenDbo token)
         {
             string id;
             LuResult<LuTokensDbo> tokenRes;
             });
         }
 
-        public LuResult<LuUsersToken> UnRegisterToken(string token)
+        public LuResult<LuUsersTokenDbo> UnRegisterToken(string token)
         {
             return this.DeleteSingleByIdDbo(token).To(dbo => dbo.ToUserToken());
         }
 
-        public bool IsTokenValid(LuUsersToken token)
+        public bool IsTokenValid(LuUsersTokenDbo token)
         {
             var now = _dateTime.Now;
             return (token.NotBefore == null || now >= token.NotBefore) &&
 
         public LuResult<string> GenerateToken(LuUsersDbo user)
         {
-            var token = new LuUsersToken
+            var token = new LuUsersTokenDbo
             {
                 Data = null,//TODO
                 NotAfter = null,
 
             return RegisterToken(token);
         }
+
+        public LuResult<LuPaginatedDbo<LuUsersTokenDbo>> GetTokensForUser(LuUsersDbo user, LuPaginatedRequestDbo paginatedRequestDbo)
+        {
+            if (paginatedRequestDbo.Filter.Filters.ContainsKey("userId"))
+            {
+                paginatedRequestDbo.Filter.Filters["userId"] = user.Id;
+            }
+            else
+            {
+                paginatedRequestDbo.Filter.Filters.Add("userId", user.Id);
+            }
+            return GetMultiple(paginatedRequestDbo)
+                .To(dbo => dbo.To(dbos => dbos.Select(tokensDbo => tokensDbo.ToUserToken()).ToList()));
+        }
     }
 }

Luticate2.Auth/Business/LuUsersBusiness.cs

 using System;
-using System.Collections.Generic;
 using System.Security.Cryptography;
 using System.Text;
 using Luticate2.Auth.DataAccess;
 using Luticate2.Auth.Interfaces.Tokens;
 using Luticate2.Auth.Interfaces.Users;
 using Luticate2.Utils.Business;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Interfaces;
 using Luticate2.Utils.Utils;
         private readonly ILuTokensBusiness _luTokensBusiness;
         private readonly ILuLoggedUserAccessor _luLoggedUserAccessor;
 
-        public LuUsersBusiness(LuUsersDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness,
-            ILuTokensBusiness luTokensBusiness, ILuLoggedUserAccessor luLoggedUserAccessor) : base(dataAccess, notificationsBusiness)
+        public LuUsersBusiness(LuUsersDataAccess dataAccess, IServiceProvider serviceProvider,
+            ILuTokensBusiness luTokensBusiness, ILuLoggedUserAccessor luLoggedUserAccessor) : base(dataAccess, serviceProvider)
         {
             _luTokensBusiness = luTokensBusiness;
             _luLoggedUserAccessor = luLoggedUserAccessor;
             }
             return base.DeleteSingleById(id, returnFunc);
         }
+
+        public LuResult<LuPaginatedDbo<LuUsersTokenDbo>> Sessions(LuPaginatedRequestDbo paginatedRequestDbo)
+        {
+            return _luTokensBusiness.GetTokensForUser(_luLoggedUserAccessor.GetLoggedUser().ToLite(), paginatedRequestDbo);
+        }
     }
 }

Luticate2.Auth/Controllers/LuAuthExtensions.cs

 using Luticate2.Auth.Attributes.EntityAccessors;
 using Luticate2.Auth.Business;
 using Luticate2.Auth.DataAccess;
+using Luticate2.Auth.Dbo.Basic;
 using Luticate2.Auth.Dbo.Users;
 using Luticate2.Auth.Interfaces.Groups;
 using Luticate2.Auth.Interfaces.Permissions;
         public const string TokenCookieName = "luticate2-token";
 
         public static IServiceCollection AddLuticateAuth(this IServiceCollection services,
-            Action<LuUtilsOptionsDbo> optionsDelegate, Action<DbContextOptionsBuilder> optionsAction)
+            Action<LuUtilsOptionsDbo> utilsOptionsDelegate, Action<DbContextOptionsBuilder> optionsAction,
+            Action<LuAuthOptionsDbo> authOptionsDelegate)
         {
-            services.AddLuticateUtils(optionsDelegate);
+            services.AddLuticateUtils(utilsOptionsDelegate);
 
             services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
 
                 optionsAction.Invoke(options);
             }, ServiceLifetime.Transient);
 
+            services.Configure(authOptionsDelegate);
+
             return services;
         }
 

Luticate2.Auth/Controllers/LuUsersController.cs

 using System.ComponentModel.DataAnnotations;
 using Luticate2.Auth.Attributes;
 using Luticate2.Auth.Business;
+using Luticate2.Auth.Dbo.Basic;
 using Luticate2.Auth.Dbo.Permissions;
 using Luticate2.Auth.Dbo.Users;
 using Luticate2.Auth.Interfaces.Users;
 using Luticate2.Utils.Controllers;
 using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.PaginatedRequest;
-using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Utils;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
         private const string WritePermission = LuPermissions.LuGroupsWrite;
 
         private readonly ILuUsersBusiness _busines;
+        private readonly LuAuthOptionsDbo _luAuthOptions;
 
-        public LuUsersController(ILuUsersBusiness busines, IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo) : base(luUtilsOptionsDbo)
+        public LuUsersController(ILuUsersBusiness busines, IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo,
+            IOptions<LuAuthOptionsDbo> luAuthOptions) : base(luUtilsOptionsDbo)
         {
             _busines = busines;
+            _luAuthOptions = luAuthOptions.Value;
         }
 
         [HttpGet("{id}")]
                 Response.Cookies.Append(LuAuthExtensions.TokenCookieName, loginRes.Data.Token, new CookieOptions
                 {
                     HttpOnly = true,
-                    Secure = true
+                    Secure = _luAuthOptions.SecureCookies
                 });
             }
             return Handle(loginRes);
         }
 
         [HttpPost("logout")]
-        public LuApiWrapperDbo<bool> Logout()
+        public LuApiWrapperDbo<bool> Logout(/*string token*/)
         {
-            var token = HttpContext.GetLuUserToken();
-            if (token != null)
+//            var t = token;
+//            if (t == null)
+//            {
+//                t = HttpContext.GetLuUserToken();
+//            }
+            var t = HttpContext.GetLuUserToken();
+            var logoutRes = _busines.Logout(t);
+            if (logoutRes/* && (token == null || t == token)*/)
             {
                 Response.Cookies.Delete(LuAuthExtensions.TokenCookieName);
-                return Handle(_busines.Logout(token));
             }
-            return Handle(LuResult<bool>.Ok(true));
+            return Handle(logoutRes);
         }
 
         [HttpGet("me")]
         {
             return Handle(_busines.Me().ToLite());
         }
+
+        [HttpGet("sessions")]
+        public LuApiWrapperDbo<LuPaginatedDbo<LuUsersTokenDbo>> Sessions(LuPaginatedRequestDbo paginatedRequestDbo)
+        {
+            return Handle(_busines.Sessions(paginatedRequestDbo));
+        }
     }
 }

Luticate2.Auth/Dbo/Basic/LuAuthOptionsDbo.cs

+namespace Luticate2.Auth.Dbo.Basic
+{
+    public class LuAuthOptionsDbo
+    {
+        public bool SecureCookies { get; set; }
+    }
+}

Luticate2.Auth/Dbo/Users/LuUsersToken.cs → Luticate2.Auth/Dbo/Users/LuUsersTokenDbo.cs

 
 namespace Luticate2.Auth.Dbo.Users
 {
-    public class LuUsersToken
+    public class LuUsersTokenDbo
     {
         public string UserId { get; set; }
 

Luticate2.Auth/Interfaces/Tokens/ILuTokensBusiness.cs

 using Luticate2.Auth.Dbo.Users;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
 
 namespace Luticate2.Auth.Interfaces.Tokens
 {
     public interface ILuTokensBusiness
     {
-        LuResult<LuUsersToken> GetToken(string token);
+        LuResult<LuUsersTokenDbo> GetToken(string token);
 
-        LuResult<string> RegisterToken(LuUsersToken token);
+        LuResult<string> RegisterToken(LuUsersTokenDbo token);
 
-        LuResult<LuUsersToken> UnRegisterToken(string token);
+        LuResult<LuUsersTokenDbo> UnRegisterToken(string token);
 
-        bool IsTokenValid(LuUsersToken token);
+        bool IsTokenValid(LuUsersTokenDbo token);
 
         LuResult<string> GenerateToken(LuUsersDbo user);
+
+        LuResult<LuPaginatedDbo<LuUsersTokenDbo>> GetTokensForUser(LuUsersDbo user, LuPaginatedRequestDbo paginatedRequestDbo);
     }
 }

Luticate2.Auth/Interfaces/Users/ILuUsersBusiness.cs

 using Luticate2.Auth.Dbo.Users;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Interfaces;
 
         LuResult<LuUsersFullDbo> Edit(string id, LuUsersEditDbo user);
 
         LuResult<LuUsersFullDbo> Me();
+
+        LuResult<LuPaginatedDbo<LuUsersTokenDbo>> Sessions(LuPaginatedRequestDbo paginatedRequestDbo);
     }
 }

Luticate2.Auth/Middlewares/LuLoggedUserMiddleware.cs

 using System;
-using Luticate2.Auth.Business;
 using Luticate2.Auth.Controllers;
 using Luticate2.Auth.Interfaces.Tokens;
 using Luticate2.Auth.Interfaces.Users;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Utils;
+using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.Mvc.Filters;
 
 namespace Luticate2.Auth.Middlewares
 
         public void OnActionExecuting(ActionExecutingContext context)
         {
+            var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
+            if (actionDescriptor == null)
+            {
+                LuResult<bool>.Error(LuStatus.InternalError,
+                    $"{nameof(LuLoggedUserMiddleware)}: actionDescriptor == null").Throw();
+                return;
+            }
+            var isLogin = false;
+            var isLogout = false;
+            if (actionDescriptor.ControllerTypeInfo.AsType() == typeof(LuUsersController))
+            {
+                if (actionDescriptor.ActionName == nameof(LuUsersController.Login))
+                {
+                    isLogin = true;
+                }
+                else if (actionDescriptor.ActionName == nameof(LuUsersController.Logout))
+                {
+                    isLogout = true;
+                }
+            }
             var token = context.HttpContext.GetLuUserToken();
             var userId = Guid.Empty.ToDbo();
-            if (token != null)
+            if (token != null && !isLogout && !isLogin)//TODO
             {
                 var tokenRes = _luTokensBusiness.GetToken(token);
                 if (tokenRes.Status == LuStatus.NotFound)

Luticate2.Auth/Middlewares/LuPermissionMiddleware.cs

 using Luticate2.Auth.Interfaces.Users;
 using Luticate2.Utils.Controllers;
 using Luticate2.Utils.Dbo.Result;
+using Microsoft.AspNetCore.Authorization.Infrastructure;
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.DependencyInjection;
         public void OnActionExecuting(ActionExecutingContext context)
         {
             var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
-            if (actionDescriptor != null)
+            if (actionDescriptor == null)
             {
-                var attributes = actionDescriptor.MethodInfo.GetCustomAttributes<LuPermissionAttribute>();
-                foreach (var attribute in attributes)
+                LuResult<bool>.Error(LuStatus.InternalError,
+                    $"{nameof(LuPermissionMiddleware)}: actionDescriptor == null").Throw();
+                return;
+            }
+            var attributes = actionDescriptor.MethodInfo.GetCustomAttributes<LuPermissionAttribute>();
+            foreach (var attribute in attributes)
+            {
+                var srcAccessor = _serviceProvider.GetService(attribute.SrcEntityAccessor) as ILuAttrEntityAccessor;
+                var dstAccessor = _serviceProvider.GetService(attribute.DstEntityAccessor) as ILuAttrEntityAccessor;
+                var srcEntity = srcAccessor?.GetEntity(context, attribute.Id);
+                var dstEntity = dstAccessor?.GetEntity(context, attribute.Id);
+                var permissionValue = _luPermissionsBusiness.GetPermissionEffectiveValue(attribute.PermissionName,
+                    attribute.SrcEntityType, srcEntity, attribute.DstEntityType, dstEntity).ThrowIfNotSuccess();
+                if (!permissionValue.Data)
                 {
-                    var srcAccessor = _serviceProvider.GetService(attribute.SrcEntityAccessor) as ILuAttrEntityAccessor;
-                    var dstAccessor = _serviceProvider.GetService(attribute.DstEntityAccessor) as ILuAttrEntityAccessor;
-                    var srcEntity = srcAccessor?.GetEntity(context, attribute.Id);
-                    var dstEntity = dstAccessor?.GetEntity(context, attribute.Id);
-                    var permissionValue = _luPermissionsBusiness.GetPermissionEffectiveValue(attribute.PermissionName,
-                        attribute.SrcEntityType, srcEntity, attribute.DstEntityType, dstEntity).ThrowIfNotSuccess();
-                    if (!permissionValue.Data)
-                    {
-                        var user = _serviceProvider.GetService<ILuLoggedUserAccessor>().GetLoggedUser();
-                        LuResult<object>.Error(LuStatus.PermissionError,$"user: {user?.Id} {user?.Username}",
-                            "Permission denied").Throw();
-                    }
+                    var user = _serviceProvider.GetService<ILuLoggedUserAccessor>().GetLoggedUser();
+                    LuResult<object>.Error(LuStatus.PermissionError,$"user: {user?.Id} {user?.Username}",
+                        "Permission denied").Throw();
                 }
             }
         }

Luticate2.Utils/Business/LuCrudBusiness.cs

 using System;
+using System.Collections.Generic;
 using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
     {
         protected readonly TDataAccess DataAccess;
 
-        private readonly ILuNotificationsBusiness _notificationsBusiness;
+        protected readonly IServiceProvider ServiceProvider;
 
-        protected virtual string EntityType { get; set; }
+        private readonly IList<Type> _listeners = new List<Type>();
 
-        protected virtual Func<string, TDboRead, bool> NotifyCreateFilter { get; set; }
-
-        protected virtual Func<string, TDboRead, TDboRead, bool> NotifyUpdateFilter { get; set; }
-
-        protected virtual Func<string, TDboRead, bool> NotifyDeleteFilter { get; set; }
-
-        protected LuCrudBusiness(TDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness)
+        protected LuCrudBusiness(TDataAccess dataAccess, IServiceProvider serviceProvider)
         {
             DataAccess = dataAccess;
-            _notificationsBusiness = notificationsBusiness;
+            ServiceProvider = serviceProvider;
+        }
+
+        public void AddListener<T>()
+            where T : ILuCrudNotifications
+        {
+            _listeners.Add(typeof(T));
         }
 
         protected virtual LuResult<TDboCreate> CheckAdd(TDboCreate obj)
             var newEntity = DataAccess.AddDbo(res.Data);
             if (newEntity)
             {
-                _notificationsBusiness.NotifyCreate(EntityType, newEntity.Data,
-                    NotifyCreateFilter != null ? s => NotifyCreateFilter(s, newEntity.Data) : (Func<string, bool>) null);
+                NotifyCreate(newEntity.Data);
                 return LuResult<T>.Ok(returnFunc(newEntity.Data));
             }
             return newEntity.To<T>();
             var editedEntity = DataAccess.EditSingleByIdDbo(id, obj.Data);
             if (editedEntity)
             {
-                _notificationsBusiness.NotifyUpdate(EntityType, originalEntity.Data, editedEntity.Data,
-                    NotifyUpdateFilter != null ? s => NotifyUpdateFilter(s, originalEntity.Data, editedEntity.Data) : (Func<string, bool>) null);
+                NotifyUpdate(originalEntity.Data, editedEntity.Data);
                 return LuResult<T>.Ok(returnFunc(editedEntity.Data));
             }
             return editedEntity.To<T>();
             var res = DataAccess.DeleteSingleById(id, returnFunc);
             if (res)
             {
-                _notificationsBusiness.NotifyDelete(EntityType, originalEntity.Data,
-                    NotifyDeleteFilter != null ? s => NotifyDeleteFilter(s, originalEntity.Data) : (Func<string, bool>) null);
+                NotifyDelete(originalEntity.Data);
             }
             return res;
         }
+
+        private void ForeachListener(Action<ILuCrudNotifications> action)
+        {
+            foreach (var listener in _listeners)
+            {
+                var instance = ServiceProvider.GetService(listener) as ILuCrudNotifications;
+                action(instance);
+            }
+        }
+
+        private void NotifyCreate(object newEntity)
+        {
+            ForeachListener(notifications => notifications.NotifyCreate(GetType(), newEntity));
+        }
+
+        private void NotifyUpdate(object oldEntity, object newEntity)
+        {
+            ForeachListener(notifications => notifications.NotifyUpdate(GetType(), oldEntity, newEntity));
+        }
+
+        private void NotifyDelete( object oldEntity)
+        {
+            ForeachListener(notifications => notifications.NotifyDelete(GetType(), oldEntity));
+        }
     }
 }

Luticate2.Utils/Business/LuCrudWebSocketNotificationsBusiness.cs

+using System;
+using Luticate2.Utils.Interfaces;
+
+namespace Luticate2.Utils.Business
+{
+    public class LuCrudWebSocketNotificationsBusiness : ILuCrudWebSocketNotificationsBusiness
+    {
+        private readonly ILuWebSocketNotificationsBusiness _luWebSocketNotificationsBusiness;
+
+        public LuCrudWebSocketNotificationsBusiness(ILuWebSocketNotificationsBusiness luWebSocketNotificationsBusiness)
+        {
+            _luWebSocketNotificationsBusiness = luWebSocketNotificationsBusiness;
+        }
+
+        public string GetEntityType(Type crudType)
+        {
+            var name = crudType.Name;
+            if (name.EndsWith("Business"))
+            {
+                name = name.Remove(name.Length - 8);
+            }
+            if (name.Length > 0 && char.IsUpper(name[0]))
+            {
+                name = char.ToLower(name[0]) + name.Remove(0, 1);
+            }
+            return name;
+        }
+
+        public void NotifyCreate(Type crudType, object newEntity)
+        {
+            _luWebSocketNotificationsBusiness.NotifyCreate(GetEntityType(crudType), newEntity);
+        }
+
+        public void NotifyUpdate(Type crudType, object oldEntity, object newEntity)
+        {
+            _luWebSocketNotificationsBusiness.NotifyUpdate(GetEntityType(crudType), oldEntity, newEntity);
+        }
+
+        public void NotifyDelete(Type crudType, object oldEntity)
+        {
+            _luWebSocketNotificationsBusiness.NotifyDelete(GetEntityType(crudType), oldEntity);
+        }
+    }
+}

Luticate2.Utils/Business/LuNotificationsBusiness.cs

-using System;
-using System.Linq;
-using Luticate2.Utils.Hubs;
-using Luticate2.Utils.Interfaces;
-using Microsoft.AspNetCore.SignalR;
-using Microsoft.AspNetCore.SignalR.Infrastructure;
-
-namespace Luticate2.Utils.Business
-{
-    public class LuNotificationsBusiness : ILuNotificationsBusiness
-    {
-        private readonly LuHubConnectionTracker _connectionTracker;
-        private readonly IHubContext _hubContext;
-
-        public const string EventCreate = "EVENT_CREATE";
-
-        public const string EventUpdate = "EVENT_UPDATE";
-
-        public const string EventDelete = "EVENT_DELETE";
-
-        public LuNotificationsBusiness(IConnectionManager connectionManager, LuHubConnectionTracker connectionTracker)
-        {
-            _connectionTracker = connectionTracker;
-            _hubContext = connectionManager.GetHubContext<LuNotificationsHub>();
-        }
-
-        public void Notify(string eventName, string entityType, object oldEntity, object newEntity, Func<string, bool> filter = null)
-        {
-            var connectionsIds = _connectionTracker.Get<LuNotificationsHub>();
-            var selectedIds = filter != null ? connectionsIds.Where(filter).ToList() : connectionsIds;
-            _hubContext.Clients.Clients(selectedIds).notify(eventName, entityType, oldEntity, newEntity);
-        }
-
-        public void NotifyCreate(string entityType, object newEntity, Func<string, bool> filter = null)
-        {
-            Notify(EventCreate, entityType, null, newEntity, filter);
-        }
-
-        public void NotifyUpdate(string entityType, object oldEntity, object newEntity, Func<string, bool> filter = null)
-        {
-            Notify(EventUpdate, entityType, oldEntity, newEntity, filter);
-        }
-
-        public void NotifyDelete(string entityType, object oldEntity, Func<string, bool> filter = null)
-        {
-            Notify(EventDelete, entityType, oldEntity, null, filter);
-        }
-    }
-}

Luticate2.Utils/Business/LuUtilsBusinessExtensions.cs

+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Interfaces;
+
+namespace Luticate2.Utils.Business
+{
+    public static class LuUtilsBusinessExtensions
+    {
+        public static void NotifyCreate(this ILuNotificationsBusiness business, string entityType, object newEntity)
+        {
+            business.Notify(LuUtilsConstants.EventCreate, entityType, null, newEntity);
+        }
+
+        public static void NotifyUpdate(this ILuNotificationsBusiness business, string entityType, object oldEntity, object newEntity)
+        {
+            business.Notify(LuUtilsConstants.EventUpdate, entityType, oldEntity, newEntity);
+        }
+
+        public static void NotifyDelete(this ILuNotificationsBusiness business, string entityType, object oldEntity)
+        {
+            business.Notify(LuUtilsConstants.EventDelete, entityType, oldEntity, null);
+        }
+    }
+}

Luticate2.Utils/Business/LuWebSocketNotificationsBusiness.cs

+using Luticate2.Utils.Hubs;
+using Luticate2.Utils.Interfaces;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.AspNetCore.SignalR.Infrastructure;
+
+namespace Luticate2.Utils.Business
+{
+    public class LuWebSocketNotificationsBusiness : ILuWebSocketNotificationsBusiness
+    {
+        private readonly LuHubConnectionTracker _connectionTracker;
+        private readonly IHubContext _hubContext;
+
+        public LuWebSocketNotificationsBusiness(IConnectionManager connectionManager, LuHubConnectionTracker connectionTracker)
+        {
+            _connectionTracker = connectionTracker;
+            _hubContext = connectionManager.GetHubContext<LuNotificationsHub>();
+        }
+
+        public void Notify(string eventName, string entityType, object oldEntity, object newEntity)
+        {
+            var connectionsIds = _connectionTracker.Get<LuNotificationsHub>();
+            _hubContext.Clients.Clients(connectionsIds).notify(eventName, entityType, oldEntity, newEntity);
+        }
+    }
+}

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

 
             services.TryAddScoped<LuEfTransactionScope>();
             services.TryAddSingleton<LuHubConnectionTracker>();
-            services.TryAddSingleton<ILuNotificationsBusiness, LuNotificationsBusiness>();
+            services.TryAddSingleton<ILuWebSocketNotificationsBusiness, LuWebSocketNotificationsBusiness>();
+            services.TryAddSingleton<ILuCrudWebSocketNotificationsBusiness, LuCrudWebSocketNotificationsBusiness>();
             services.Configure(optionsDelegate);
             return services;
         }

Luticate2.Utils/Dbo/Basic/LuUtilsConstants.cs

+namespace Luticate2.Utils.Dbo.Basic
+{
+    public class LuUtilsConstants
+    {
+        public const string EventCreate = "EVENT_CREATE";
+
+        public const string EventUpdate = "EVENT_UPDATE";
+
+        public const string EventDelete = "EVENT_DELETE";
+    }
+}

Luticate2.Utils/Interfaces/ILuCrudNotifications.cs

+using System;
+
+namespace Luticate2.Utils.Interfaces
+{
+    public interface ILuCrudNotifications
+    {
+        void NotifyCreate(Type crudType, object newEntity);
+
+        void NotifyUpdate(Type crudType, object oldEntity, object newEntity);
+
+        void NotifyDelete(Type crudType, object oldEntity);
+    }
+}

Luticate2.Utils/Interfaces/ILuCrudWebSocketNotificationsBusiness.cs

+namespace Luticate2.Utils.Interfaces
+{
+    public interface ILuCrudWebSocketNotificationsBusiness : ILuCrudNotifications
+    {
+
+    }
+}

Luticate2.Utils/Interfaces/ILuNotificationsBusiness.cs

-using System;
-
-namespace Luticate2.Utils.Interfaces
+namespace Luticate2.Utils.Interfaces
 {
     public interface ILuNotificationsBusiness
     {
-        void Notify(string eventName, string entityType, object oldEntity, object newEntity,
-            Func<string, bool> filter = null);
-
-        void NotifyCreate(string entityType, object newEntity, Func<string, bool> filter = null);
-
-        void NotifyUpdate(string entityType, object oldEntity, object newEntity,
-            Func<string, bool> filter = null);
-
-        void NotifyDelete(string entityType, object oldEntity, Func<string, bool> filter = null);
+        void Notify(string eventName, string entityType, object oldEntity, object newEntity);
     }
 }

Luticate2.Utils/Interfaces/ILuWebSocketNotificationsBusiness.cs

+namespace Luticate2.Utils.Interfaces
+{
+    public interface ILuWebSocketNotificationsBusiness : ILuNotificationsBusiness
+    {
+
+    }
+}

TestAuth/Tests.cs

 {
     public class DummyNotificationsBusiness : ILuNotificationsBusiness
     {
-        public void Notify(string eventName, string entityType, object oldEntity, object newEntity, Func<string, bool> filter = null)
-        {
-        }
-
-        public void NotifyCreate(string entityType, object newEntity, Func<string, bool> filter = null)
-        {
-        }
-
-        public void NotifyUpdate(string entityType, object oldEntity, object newEntity, Func<string, bool> filter = null)
-        {
-        }
-
-        public void NotifyDelete(string entityType, object oldEntity, Func<string, bool> filter = null)
+        public void Notify(string eventName, string entityType, object oldEntity, object newEntity)
         {
         }
     }
             }, builder =>
             {
                 builder.UseNpgsql(RealDbConnectionString);
+            }, dbo =>
+            {
+                dbo.SecureCookies = false;
             });
             return serviceCollection.BuildServiceProvider();
         }

WebApiAuth/Startup.cs

             services.AddLuticateAuth(options => options.Version = "dev", options =>
             {
                 options.UseNpgsql(Configuration.GetConnectionString("default"));
-            });
+            }, options => options.SecureCookies = false);
 
             services.AddMvc()
                 .AddLuticateAuth();

WebApiUtils/Business/PkGuidBusiness.cs

-using Luticate2.Utils.Business;
-using Luticate2.Utils.Interfaces;
-using TestUtils.DataAccess;
-using TestUtils.Dbo.PkGuid;
-
-namespace WebApiUtils.Business
-{
-    public class PkGuidBusiness : LuCrudBusiness<LuUtilsPkGuidDataAccess, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, string>
-    {
-        public PkGuidBusiness(LuUtilsPkGuidDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness) : base(dataAccess, notificationsBusiness)
-        {
-            EntityType = "pkguids";
-        }
-    }
-}

WebApiUtils/Business/PkGuidsBusiness.cs

+using System;
+using Luticate2.Utils.Business;
+using Luticate2.Utils.Interfaces;
+using TestUtils.DataAccess;
+using TestUtils.Dbo.PkGuid;
+
+namespace WebApiUtils.Business
+{
+    public class PkGuidsBusiness : LuCrudBusiness<LuUtilsPkGuidDataAccess, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, string>
+    {
+        public PkGuidsBusiness(LuUtilsPkGuidDataAccess dataAccess, IServiceProvider serviceProvider) : base(dataAccess, serviceProvider)
+        {
+            AddListener<ILuCrudWebSocketNotificationsBusiness>();
+        }
+    }
+}

WebApiUtils/Business/UploadBusiness.cs

-using Luticate2.Utils.Business;
+using System;
+using Luticate2.Utils.Business;
 using Luticate2.Utils.Dbo.FsFiles;
-using Luticate2.Utils.Interfaces;
 using WebApiUtils.DataAccess;
 
 namespace WebApiUtils.Business
 {
     public class UploadBusiness : LuCrudBusiness<UploadDataAccess, LuFsFilesAddDbo, LuFsFilesDbo, LuFsFilesAddDbo, string>
     {
-        public UploadBusiness(UploadDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness) : base(dataAccess, notificationsBusiness)
+        public UploadBusiness(UploadDataAccess dataAccess, IServiceProvider serviceProvider) : base(dataAccess, serviceProvider)
         {
         }
     }

WebApiUtils/Controllers/PkGuidController.cs

 
 namespace WebApiUtils.Controllers
 {
-    public class PkGuidController : LuCrudController<PkGuidBusiness, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, string>
+    public class PkGuidController : LuCrudController<PkGuidsBusiness, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo, string>
     {
-        public PkGuidController(PkGuidBusiness busines, IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo) : base(busines, luUtilsOptionsDbo)
+        public PkGuidController(PkGuidsBusiness busines, IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo) : base(busines, luUtilsOptionsDbo)
         {
         }
     }

WebApiUtils/Startup.cs

 
             services.AddLuticateUtils(options => options.Version = "dev");
 
-            services.AddScoped<PkGuidBusiness>();
+            services.AddScoped<PkGuidsBusiness>();
             services.AddScoped<LuUtilsPkGuidDataAccess>();
             services.AddScoped<UploadBusiness>();
             services.AddScoped<UploadDataAccess>();