yea

2026-06-12 15:35:10 -04:00
parent f5716c7160
commit 6706b6f478
60 changed files with 48656 additions and 0 deletions
@@ -0,0 +1,211 @@
+using Microsoft.AspNetCore.Mvc;
+using FemRec2023.Classes;
+using FemRec2023.Classes.DBs;
+using FemRec2023.Classes.DBs.DBClasses;
+using FemRec2023.Auth;
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Concurrent;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+using static FemRec2023.Classes.DBs.DBClasses.PlayerDBClasses;
+
+namespace FemRec2023.Controllers
+{
+    [ApiController]
+    [Route("/noti")]
+    public class NotiController : ControllerBase
+    {
+        public static ConcurrentDictionary<string, WebSocket> WebSockets { get; } = new();
+        public static ConcurrentDictionary<long, HashSet<string>> PlayerConnections { get; } = new();
+
+        [HttpPost("hub/v1/negotiate")]
+        public IActionResult Negotiate()
+        {
+            var id = AuthStuff.GetPlayerId(Request);
+            if (id == null) 
+            	return Unauthorized();
+
+            string connectionId = Guid.NewGuid().ToString("N");
+
+            var response = new
+            {
+                negotiateVersion = 0,
+                connectionId = connectionId,
+                availableTransports = new[]
+                {
+                    new
+                    {
+                        transport = "WebSockets",
+                        transferFormats = new[] { "Text", "Binary" }
+                    }
+                }
+            };
+
+            return Ok(response);
+        }
+
+        [Route("hub/v1")]
+        public async Task HandleHub([FromQuery] string id)
+        {
+            var playerId = AuthStuff.GetPlayerId(Request);
+            if (playerId == null)
+            {
+            	Console.WriteLine($"[WebSocket] Player is unauthorized");
+                HttpContext.Response.StatusCode = StatusCodes.Status401Unauthorized;
+                return;
+            }
+
+            if (!HttpContext.WebSockets.IsWebSocketRequest)
+            {
+            	Console.WriteLine($"[WebSocket] IsWebSocketRequest is false");
+                HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
+                return;
+            }
+
+
+            using var socket = await HttpContext.WebSockets.AcceptWebSocketAsync();
+            Console.WriteLine($"[WebSocket] Player {playerId} connected with connection {id}");
+
+            PlayerConnections.AddOrUpdate(
+                (long)playerId,
+                _ => new HashSet<string> { id },
+                (_, hs) =>
+                {
+                    lock (hs) { hs.Add(id); }
+                    return hs;
+                }
+            );
+
+            await HandleConnectionAsync((long)playerId, id, socket);
+        }
+
+        private static async Task HandleConnectionAsync(long playerId, string connectionId, WebSocket socket)
+        {
+            using var pingCts = new CancellationTokenSource();
+
+            try
+            {
+                WebSockets[connectionId] = socket;
+
+                await SendHandshakeAsync(socket);
+
+                _ = Task.Run(() => PingLoopAsync(socket, pingCts.Token));
+
+                var buffer = new byte[4096];
+                while (socket.State == WebSocketState.Open)
+                {
+                    var result = await socket.ReceiveAsync(buffer, CancellationToken.None);
+                    if (result.MessageType == WebSocketMessageType.Close)
+                        break;
+
+                    var message = Encoding.UTF8.GetString(buffer, 0, result.Count).TrimEnd('\x1e');
+                    Console.WriteLine($"Player ({playerId}) sent: {message}");
+
+                    await HandleClientMessageAsync(socket, message);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"[Error:{connectionId}] {ex.Message}");
+            }
+            finally
+            {
+                pingCts.Cancel();
+                WebSockets.TryRemove(connectionId, out _);
+
+                if (PlayerConnections.TryGetValue(playerId, out var connections))
+                {
+                    lock (connections)
+                    {
+                        connections.Remove(connectionId);
+
+                        if (connections.Count == 0)
+                            PlayerConnections.TryRemove(playerId, out _);
+                    }
+                }
+
+                if (socket.State is WebSocketState.Open or WebSocketState.CloseReceived)
+                {
+                    await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing connection", CancellationToken.None);
+                }
+
+                Console.WriteLine($"[WebSocket] Player {playerId} disconnected from connection {connectionId}");
+            }
+        }
+
+        private static async Task HandleClientMessageAsync(WebSocket socket, string message)
+        {
+            try
+            {
+                using var doc = JsonDocument.Parse(message);
+                var root = doc.RootElement;
+
+                if (root.TryGetProperty("type", out var typeProp) && typeProp.GetInt32() == 1)
+                {
+                    string target = root.GetProperty("target").GetString() ?? string.Empty;
+                    string invocationId = root.GetProperty("invocationId").GetString() ?? string.Empty;
+
+                    if (target == "SubscribeToPlayers")
+                    {
+                        var response = new
+                        {
+                            type = 3,
+                            invocationId = invocationId,
+                            result = (object?)null
+                        };
+                        await SendJsonAsync(socket, response);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"[ParseError] {ex.Message}");
+            }
+        }
+
+        private static async Task SendHandshakeAsync(WebSocket socket)
+        {
+            var handshake = new { protocol = "json", version = 1 };
+            await SendJsonAsync(socket, handshake);
+        }
+
+        private static async Task PingLoopAsync(WebSocket socket, CancellationToken token)
+        {
+            try
+            {
+                while (!token.IsCancellationRequested && socket.State == WebSocketState.Open)
+                {
+                    var ping = new { type = 6 };
+                    await SendJsonAsync(socket, ping);
+                    await Task.Delay(10000, token);
+                }
+            }
+            catch (TaskCanceledException) { }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"[PingError] {ex.Message}");
+            }
+        }
+        public static async Task SendNotificationToPlayer(long playerId, object message)
+        {
+            if (!PlayerConnections.TryGetValue(playerId, out var connections))
+                return;
+
+            foreach (var connectionId in connections)
+            {
+                if (WebSockets.TryGetValue(connectionId, out var socket) && socket.State == WebSocketState.Open)
+                {
+                    await SendJsonAsync(socket, message);
+                }
+            }
+        }
+
+        private static async Task SendJsonAsync(WebSocket socket, object obj)
+        {
+            var json = JsonSerializer.Serialize(obj) + "\x1e";
+            var bytes = Encoding.UTF8.GetBytes(json);
+            await socket.SendAsync(bytes, WebSocketMessageType.Text, true, CancellationToken.None);
+        }
+    }
+}