Initial upload

api/server/Notifications.cs

@@ -0,0 +1,126 @@
+using Newtonsoft.Json;
+using Rec_rewild_live_rewrite.api.dbs;
+using RewildLiveSource.Controllers;
+using System.Net.WebSockets;
+using System.Security.Principal;
+using System.Text;
+
+namespace Rec_rewild_live_rewrite.api.server
+{
+    public static class Notifications
+    {
+        private static readonly byte[] Separator = Encoding.UTF8.GetBytes("\u001e");
+
+        public static async Task SendToPlayer(ulong playerId, string message)
+        {
+            if (!NotificationsController.WebSockets.TryGetValue(playerId, out var socket) || socket == null)
+            {
+                Console.WriteLine($"[Notifications] No active WebSocket for player {playerId}");
+                return;
+            }
+
+            await SendAsync(socket, message, playerId);
+        }
+
+        public static async Task SendToAll(string message)
+        {
+            var tasks = NotificationsController.WebSockets
+                .Select(kv => SendAsync(kv.Value, message, kv.Key));
+
+            await Task.WhenAll(tasks);
+        }
+
+        public static async Task SendToPlayers(List<ulong> playerIds, string message)
+        {
+            var tasks = new List<Task>();
+
+            foreach (var id in playerIds)
+            {
+                if (NotificationsController.WebSockets.TryGetValue(id, out var socket) && socket != null)
+                    tasks.Add(SendAsync(socket, message, id));
+            }
+
+            await Task.WhenAll(tasks);
+        }
+
+        private static async Task SendAsync(WebSocket socket, string message, ulong? playerId = null)
+        {
+            if (socket == null || socket.State != WebSocketState.Open)
+                return;
+
+            var packet = new SockSignalR
+            {
+                type = MessageTypes.Idk,
+                target = "Notification",
+                arguments = new object[] { message },
+                nonblocking = true,
+                result = "200 OK"
+            };
+
+            var data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(packet));
+            var buffer = new byte[data.Length + Separator.Length];
+            Buffer.BlockCopy(data, 0, buffer, 0, data.Length);
+            Buffer.BlockCopy(Separator, 0, buffer, data.Length, Separator.Length);
+
+            Console.WriteLine($"[Notifications] Sending to {(playerId.HasValue ? playerId.ToString() : "unknown player")}: {buffer}");
+
+            try
+            {
+                await socket.SendAsync(
+                    new ArraySegment<byte>(buffer),
+                    WebSocketMessageType.Text,
+                    endOfMessage: true,
+                    cancellationToken: CancellationToken.None
+                );
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"[Notifications] Failed to send to {(playerId.HasValue ? playerId.ToString() : "unknown player")}: {ex.Message}");
+
+                try
+                {
+                    await socket.CloseAsync(WebSocketCloseStatus.InternalServerError, "Send failed", CancellationToken.None);
+                }
+                catch 
+                { 
+
+                }
+            }
+        }
+
+        public static async Task<bool> RefreshAccount(ulong accountId)
+        {
+            try
+            {
+                var selfUpdate = JsonConvert.SerializeObject(WebsocketEvents.create_player_updated_account2_Response("SelfAccountUpdate", PlayerDB.GetAccountMeSafe(accountId)));
+                var globalUpdate = JsonConvert.SerializeObject(WebsocketEvents.create_player_updated_account2_Response("AccountUpdate", PlayerDB.GetAccountMeSafe(accountId)));
+
+                var notifySelfTask = Notifications.SendToPlayer(accountId, selfUpdate);
+                var notifyAllTask = Notifications.SendToAll(globalUpdate);
+
+                await Task.WhenAll(notifySelfTask, notifyAllTask);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Failed to send notification: {ex.Message}");
+                return false;
+            }
+        }
+
+        private class SockSignalR
+        {
+            public MessageTypes type { get; set; }
+            public string? target { get; set; }
+            public object[]? arguments { get; set; }
+            public bool nonblocking { get; set; }
+            public object? result { get; set; }
+        }
+
+        private enum MessageTypes
+        {
+            Invocation,
+            Idk
+        }
+    }
+}