use SignalR for AlertDropdown

Signum.React.Extensions/Alerts/AlertController.cs

@@ -4,7 +4,7 @@
 using Signum.React.Filters;
 using Signum.Entities.Alerts;
 
-namespace Signum.React.Authorization;
+namespace Signum.React.Alerts;
 
 [ValidateModelFilter]
 public class AlertController : ControllerBase

Signum.React.Extensions/Alerts/AlertDropdown.tsx

@@ -1,13 +1,10 @@
 import * as React from 'react'
-import { isRtl } from '@framework/AppContext'
 import * as Operations from '@framework/Operations'
-import { getTypeInfo, symbolNiceName } from '@framework/Reflection'
 import * as Finder from '@framework/Finder'
 import { is, JavascriptMessage, toLite } from '@framework/Signum.Entities'
-import { Toast, NavItem, Button, ButtonGroup } from 'react-bootstrap'
+import { Toast, Button, ButtonGroup } from 'react-bootstrap'
 import { DateTime } from 'luxon'
-import { useAPI, useAPIWithReload, useDocumentEvent, useForceUpdate, useInterval, usePrevious, useThrottle, useUpdatedRef } from '@framework/Hooks';
-import { LinkContainer } from '@framework/Components'
+import { useAPIWithReload, useForceUpdate, useUpdatedRef } from '@framework/Hooks';
 import * as AuthClient from '../Authorization/AuthClient'
 import * as Navigator from '@framework/Navigator'
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
@@ -17,27 +14,33 @@ import "./AlertDropdown.css"
 import { Link } from 'react-router-dom';
 import { classes, Dic } from '@framework/Globals'
 import MessageModal from '@framework/Modals/MessageModal'
-import { EntityLink } from '@framework/Search'
+import { useSignalRCallback, useSignalRConnection } from './useSignalR'
 
-export default function AlertDropdown(props: { checkForChangesEvery?: number, keepRingingFor?: number }) {
+export default function AlertDropdown(props: { keepRingingFor?: number }) {
 
   if (!Navigator.isViewable(AlertEntity))
     return null;
 
-  return <AlertDropdownImp checkForChangesEvery={props.checkForChangesEvery ?? 30 * 1000} keepRingingFor={props.keepRingingFor ?? 10 * 1000} />;
+  return <AlertDropdownImp keepRingingFor={props.keepRingingFor ?? 10 * 1000} />;
 }
 
-function AlertDropdownImp(props: { checkForChangesEvery: number, keepRingingFor: number }) {
+function AlertDropdownImp(props: { keepRingingFor: number }) {
+
+  const conn = useSignalRConnection("~/api/alertshub", {
+    accessTokenFactory: () => AuthClient.getAuthToken()!,
+  });
+
+  useSignalRCallback(conn, "AlertsChanged", () => {
+    reloadCount();
+  }, []);
 
   const forceUpdate = useForceUpdate();
   const [isOpen, setIsOpen] = React.useState<boolean>(false);
   const [ringing, setRinging] = React.useState<boolean>(false);
   const ringingRef = useUpdatedRef(ringing);
 
   const [showAlerts, setShowAlert] = React.useState<number>(5);
-
-  var ticks = useInterval(props.checkForChangesEvery, 0, n => n + 1);
-
+
   const isOpenRef = useUpdatedRef(isOpen);
 
   var [countResult, reloadCount] = useAPIWithReload<AlertsClient.NumAlerts>((signal, oldResult) => AlertsClient.API.myAlertsCount().then(res => {
@@ -63,7 +66,7 @@ function AlertDropdownImp(props: { checkForChangesEvery: number, keepRingingFor:
     }
 
     return res;
-  }), [ticks], { avoidReset: true });
+  }), [], { avoidReset: true });
 
   React.useEffect(() => {
     if (ringing) {
@@ -75,10 +78,6 @@ function AlertDropdownImp(props: { checkForChangesEvery: number, keepRingingFor:
     }
   }, [ringing]);
 
-  useDocumentEvent("refresh-alerts", (e: Event) => {
-    reloadCount();
-  }, []);
-
   const [alerts, setAlerts] = React.useState<AlertEntity[] | undefined>(undefined);
   const [groupBy, setGroupBy] = React.useState<AlertDropDownGroup>("ByTypeAndUser");
 
@@ -108,8 +107,6 @@ function AlertDropdownImp(props: { checkForChangesEvery: number, keepRingingFor:
       countResult.numAlerts -= toRemove.length;
     forceUpdate();
 
-
-
     Operations.API.executeMultiple(toRemove.map(a => toLite(a)), AlertOperation.Attend)
       .then(res => {
 

Signum.React.Extensions/Alerts/AlertsClient.tsx

@@ -60,11 +60,14 @@ export function start(options: { routes: JSX.Element[], showAlerts?: (typeName:
 
   var cellFormatter = new Finder.CellFormatter((cell, ctx) => {
 
+    if (cell == null)
+      return undefined;
+
     var alert: Partial<AlertEntity> = {
       target: ctx.row.columns[ctx.columns.indexOf(AlertEntity.token(a => a.target).toString())],
       textArguments: ctx.row.columns[ctx.columns.indexOf(AlertEntity.token(a => a.entity.textArguments).toString())]
     };
-    return formatText(cell, alert);
+    return  formatText(cell, alert);
   });
 
   Finder.registerPropertyFormatter(PropertyRoute.tryParse(AlertEntity, "Text"), cellFormatter);
@@ -120,10 +123,13 @@ export function getTitle(titleField: string | null, type: AlertTypeSymbol | null
   if (titleField)
     return titleField;
 
-  if (type!.key)
+  if (type == null)
+    return " - ";
+
+  if (type.key)
     return symbolNiceName(type! as Entity & ISymbol);
 
-  return type!.name;
+  return type.name;
 }
 export function formatText(text: string, alert: Partial<AlertEntity>, onNavigated?: () => void): React.ReactElement {
   var nodes: (string | React.ReactElement)[] = [];

Signum.React.Extensions/Alerts/AlertsHub.cs

@@ -0,0 +1,98 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.SignalR;
+using Signum.Entities.Basics;
+using Signum.React.Alerts;
+using Signum.React.Authorization;
+using System.Threading.Tasks;
+
+namespace Signum.React.Facades;
+
+public interface IAlertsClient
+{
+    Task AlertsChanged();
+}
+
+public class AlertsHub : Hub<IAlertsClient>
+{
+    public override Task OnConnectedAsync()
+    {
+        var user = GetUser(Context.GetHttpContext()!);
+
+        AlertsServer.Connections.Add(user.ToLite(), Context.ConnectionId);
+
+        return base.OnConnectedAsync();
+    }
+
+    public override Task OnDisconnectedAsync(Exception? exception)
+    {
+        AlertsServer.Connections.Remove(Context.ConnectionId);
+        return base.OnDisconnectedAsync(exception);
+    }
+
+    IUserEntity GetUser(HttpContext httpContext)
+    {
+        var tokenString = httpContext.Request.Query["access_token"];
+        if (tokenString.Count > 1)
+            throw new InvalidOperationException($"{tokenString.Count} values in 'access_token' query string found");
+
+        if (tokenString.Count == 0)
+        {
+            tokenString = httpContext.Request.Headers["Authorization"];
+
+            if (tokenString.Count != 1)
+                throw new InvalidOperationException($"{tokenString.Count} values in 'Authorization' header found");
+        }
+
+        var token = AuthTokenServer.DeserializeToken(tokenString.SingleEx());
+
+        return token.User;
+    }
+}
+
+public class ConnectionMapping<T> where T : class
+{
+    private readonly Dictionary<T, HashSet<string>> userToConnection = new Dictionary<T, HashSet<string>>();
+    private readonly Dictionary<string, T> connectionToUser = new Dictionary<string, T>();
+
+    public int Count => userToConnection.Count;
+
+    public void Add(T key, string connectionId)
+    {
+        lock (this)
+        {
+            HashSet<string>? connections;
+            if (!userToConnection.TryGetValue(key, out connections))
+            {
+                connections = new HashSet<string>();
+                userToConnection.Add(key, connections);
+            }
+
+            connections.Add(connectionId);
+
+            connectionToUser.Add(connectionId, key);
+        }
+    }
+
+    public IEnumerable<string> GetConnections(T key) => userToConnection.TryGetC(key) ?? Enumerable.Empty<string>();
+
+    public void Remove(string connectionId)
+    {
+        lock (this)
+        {
+            var user = connectionToUser.TryGetC(connectionId);
+            if (user != null)
+            {
+                HashSet<string>? connections = userToConnection.TryGetC(user);
+                if (connections != null)
+                {
+                    connections.Remove(connectionId);
+                    if (connections.Count == 0)
+                        userToConnection.Remove(user);
+                }
+
+                connectionToUser.Remove(connectionId);
+            }
+        }
+    }
+}
+

Signum.React.Extensions/Alerts/AlertsServer.cs

@@ -1,12 +1,93 @@
 using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.AspNetCore.SignalR;
+using Signum.Entities.Alerts;
+using Signum.Entities.Authorization;
+using Signum.Entities.Basics;
+using Signum.React.Facades;
 
 namespace Signum.React.Alerts;
 
 public static class AlertsServer
 {
+    internal static ConnectionMapping<Lite<IUserEntity>> Connections = null!;
+
+    public static IHubContext<AlertsHub, IAlertsClient> AlertsHub { get; private set; }
+
     public static void Start(IApplicationBuilder app)
     {
         SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
+    }
+
+    public static void MapAlertsHub(IEndpointRouteBuilder endpoints)
+    {
+        endpoints.MapHub<AlertsHub>("/api/alertshub");
+        Connections = new ConnectionMapping<Lite<IUserEntity>>();
+        AlertsHub = (IHubContext<AlertsHub, IAlertsClient>)endpoints.ServiceProvider.GetService(typeof(IHubContext<AlertsHub, IAlertsClient>))!;
+
+        var alertEvents = Schema.Current.EntityEvents<AlertEntity>();
+
+        alertEvents.Saved += AlertEvents_Saved;
+        alertEvents.PreUnsafeDelete += AlertEvents_PreUnsafeDelete;
+        alertEvents.PreUnsafeUpdate += AlertEvents_PreUnsafeUpdate;
+        alertEvents.PreUnsafeInsert += AlertEvents_PreUnsafeInsert;
+    }
+
+    private static IDisposable? AlertEvents_PreUnsafeUpdate(IUpdateable update, IQueryable<AlertEntity> entityQuery)
+    {
+        NotifyOnCommitQuery(entityQuery);
+        return null;
+    }
+
+    private static LambdaExpression AlertEvents_PreUnsafeInsert(IQueryable query, LambdaExpression constructor, IQueryable<AlertEntity> entityQuery)
+    {
+        NotifyOnCommitQuery(entityQuery);
+        return constructor;
+    }
 
+    private static IDisposable? AlertEvents_PreUnsafeDelete(IQueryable<AlertEntity> entityQuery)
+    {
+        NotifyOnCommitQuery(entityQuery);
+        return null;
+    }
+
+    private static void AlertEvents_Saved(AlertEntity ident, SavedEventArgs args)
+    {
+        if (ident.Recipient != null)
+            NotifyOnCommit(ident.Recipient);
+    }
+
+    private static void NotifyOnCommitQuery(IQueryable<AlertEntity> alerts)
+    {
+        var recipients = alerts.Where(a => a.Recipient != null && a.State == AlertState.Saved).Select(a => a.Recipient!).Distinct().ToArray();
+        if (recipients.Any())
+            NotifyOnCommit(recipients);
+    }
+    private static void NotifyOnCommit(params Lite<IUserEntity>[] recipients)
+    {
+        var hs = (HashSet<Lite<IUserEntity>>)Transaction.UserData.GetOrCreate("AlertRecipients", new HashSet<Lite<IUserEntity>>());
+        hs.AddRange(recipients);
+
+        Transaction.PostRealCommit -= Transaction_PostRealCommit;
+        Transaction.PostRealCommit += Transaction_PostRealCommit;
+    }
+
+    private static void Transaction_PostRealCommit(Dictionary<string, object> dic)
+    {
+        var hashSet = (HashSet<Lite<IUserEntity>>)dic["AlertRecipients"];
+        foreach (var user in hashSet)
+        {
+            foreach (var connectionId in Connections.GetConnections(user))
+            {
+                try
+                {
+                    AlertsServer.AlertsHub.Clients.Client(connectionId).AlertsChanged();
+                }
+                catch(Exception ex)
+                {
+                    ex.LogException();
+                }
+            }
+        }
     }
 }