track websocket connections; filter lunotifications

Luticate2.Utils/Business/LuCrudBusiness.cs

 
         private readonly LuNotificationsBusiness _notificationsBusiness;
 
-        protected string EntityType = null;
+        protected virtual string EntityType { get; set; }
 
         protected LuCrudBusiness(TDataAccess dataAccess, LuNotificationsBusiness notificationsBusiness)
         {
             _notificationsBusiness = notificationsBusiness;
         }
 
-        protected virtual string GetEntityType()
-        {
-            return EntityType;
-        }
-
         protected virtual LuResult<TDboCreate> CheckAdd(TDboCreate obj)
         {
             return LuResult<TDboCreate>.Ok(obj);
             var newEntity = DataAccess.AddDbo(res.Data);
             if (newEntity)
             {
-                _notificationsBusiness.NotifyCreate(GetEntityType(), newEntity.Data);
+                _notificationsBusiness.NotifyCreate(EntityType, newEntity.Data);
                 return LuResult<T>.Ok(returnFunc(newEntity.Data));
             }
             return newEntity.To<T>();
             var editedEntity = DataAccess.EditSingleByIdDbo(id, obj.Data);
             if (editedEntity)
             {
-                _notificationsBusiness.NotifyUpdate(GetEntityType(), originalEntity.Data, editedEntity.Data);
+                _notificationsBusiness.NotifyUpdate(EntityType, 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(GetEntityType(), originalEntity.Data);
+                _notificationsBusiness.NotifyDelete(EntityType, originalEntity.Data);
             }
             return res;
         }

Luticate2.Utils/Business/LuNotificationsBusiness.cs

-using Luticate2.Utils.Hubs;
+using System;
+using System.Linq;
+using Luticate2.Utils.Hubs;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.AspNetCore.SignalR.Infrastructure;
 
 {
     public class LuNotificationsBusiness
     {
+        private readonly LuHubConnectionTracker _connectionTracker;
         private readonly IHubContext _hubContext;
 
         public const string EventCreate = "EVENT_CREATE";
 
         public const string EventDelete = "EVENT_DELETE";
 
-        public LuNotificationsBusiness(IConnectionManager connectionManager)
+        public LuNotificationsBusiness(IConnectionManager connectionManager, LuHubConnectionTracker connectionTracker)
         {
+            _connectionTracker = connectionTracker;
             _hubContext = connectionManager.GetHubContext<LuNotificationsHub>();
         }
 
-        public void Notify(string eventName, string entityType, object oldEntity, object newEntity)
+        public void Notify(string eventName, string entityType, object oldEntity, object newEntity, Func<string, bool> filter = null)
         {
-            _hubContext.Clients.All.notify(eventName, entityType, oldEntity, newEntity);
+            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)
+        public void NotifyCreate(string entityType, object newEntity, Func<string, bool> filter = null)
         {
-            Notify(EventCreate, entityType, null, newEntity);
+            Notify(EventCreate, entityType, null, newEntity, filter);
         }
 
-        public void NotifyUpdate(string entityType, object oldEntity, object newEntity)
+        public void NotifyUpdate(string entityType, object oldEntity, object newEntity, Func<string, bool> filter = null)
         {
-            Notify(EventUpdate, entityType, oldEntity, newEntity);
+            Notify(EventUpdate, entityType, oldEntity, newEntity, filter);
         }
 
-        public void NotifyDelete(string entityType, object oldEntity)
+        public void NotifyDelete(string entityType, object oldEntity, Func<string, bool> filter = null)
         {
-            Notify(EventDelete, entityType, oldEntity, null);
+            Notify(EventDelete, entityType, oldEntity, null, filter);
         }
     }
 }

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

                 options.Hubs.EnableDetailedErrors = true;
             });
 
+            services.AddSingleton<LuHubConnectionTracker>();
             services.AddSingleton<LuNotificationsBusiness>();
             Options = new LuOptionsDbo();
             optionsDelegate(Options);

Luticate2.Utils/Hubs/LuHub.cs

+using System.Threading.Tasks;
+using Microsoft.AspNetCore.SignalR;
+
+namespace Luticate2.Utils.Hubs
+{
+    public class LuHub : Hub
+    {
+        private readonly LuHubConnectionTracker _connectionTracker;
+
+        public LuHub(LuHubConnectionTracker connectionTracker)
+        {
+            _connectionTracker = connectionTracker;
+        }
+
+        public override Task OnConnected()
+        {
+            _connectionTracker.Add(this, Context.ConnectionId);
+            return base.OnConnected();
+        }
+
+        public override Task OnDisconnected(bool stopCalled)
+        {
+            _connectionTracker.Remove(this, Context.ConnectionId);
+            return base.OnDisconnected(stopCalled);
+        }
+    }
+}

Luticate2.Utils/Hubs/LuHubConnectionTracker.cs

+using System;
+using System.Collections.Generic;
+
+namespace Luticate2.Utils.Hubs
+{
+    public class LuHubConnectionTracker
+    {
+        protected IDictionary<string, IList<string>> ConnectionIds { get; set; }
+
+        public LuHubConnectionTracker()
+        {
+            ConnectionIds = new Dictionary<string, IList<string>>();
+        }
+
+        public static string GetNameFromType(Type type)
+        {
+            return type.FullName;
+        }
+
+
+
+        public void Add(string name, string id)
+        {
+            GetReal(name).Add(id);
+        }
+
+        public void Add(Type type, string id)
+        {
+            Add(GetNameFromType(type), id);
+        }
+
+        public void Add(object obj, string id)
+        {
+            Add(obj.GetType(), id);
+        }
+
+        public void Add<T>(string id)
+        {
+            Add(typeof(T), id);
+        }
+
+
+
+        public void Remove(string name, string id)
+        {
+            GetReal(name).Remove(id);
+        }
+
+        public void Remove(Type type, string id)
+        {
+            Remove(GetNameFromType(type), id);
+        }
+
+        public void Remove(object obj, string id)
+        {
+            Remove(obj.GetType(), id);
+        }
+
+        public void Remove<T>(string id)
+        {
+            Remove(typeof(T), id);
+        }
+
+
+
+        public IList<string> GetReal(string name)
+        {
+            if (!ConnectionIds.ContainsKey(name))
+            {
+                ConnectionIds.Add(name, new List<string>());
+            }
+            return ConnectionIds[name];
+        }
+
+        public IList<string> Get(string name)
+        {
+            return new List<string>(GetReal(name));
+        }
+
+        public IList<string> Get(Type type)
+        {
+            return Get(GetNameFromType(type));
+        }
+
+        public IList<string> Get(object obj)
+        {
+            return Get(GetNameFromType(obj.GetType()));
+        }
+
+        public IList<string> Get<T>()
+        {
+            return Get(GetNameFromType(typeof(T)));
+        }
+
+    }
+}

Luticate2.Utils/Hubs/LuNotificationsHub.cs

-using Microsoft.AspNetCore.SignalR;
-
+
 namespace Luticate2.Utils.Hubs
 {
-    public class LuNotificationsHub : Hub
+    public class LuNotificationsHub : LuHub
     {
-
+        public LuNotificationsHub(LuHubConnectionTracker connectionTracker) : base(connectionTracker)
+        {
+        }
     }
 }