✨ Chat subscribe fixes and status update

DysonNetwork.Sphere/Chat/ChatRoomController.cs

@@ -483,6 +483,36 @@ public class ChatRoomController(
         return Ok(await crs.LoadMemberAccount(member));
     }
 
+    [HttpGet("{roomId:guid}/members/online")]
+    public async Task<ActionResult<int>> GetOnlineUsersCount(Guid roomId)
+    {
+        var currentUser = HttpContext.Items["CurrentUser"] as Account;
+
+        var room = await db.ChatRooms
+            .FirstOrDefaultAsync(r => r.Id == roomId);
+        if (room is null) return NotFound();
+
+        if (!room.IsPublic)
+        {
+            if (currentUser is null) return Unauthorized();
+            var member = await db.ChatMembers
+                .FirstOrDefaultAsync(m => m.ChatRoomId == roomId && m.AccountId == Guid.Parse(currentUser.Id));
+            if (member is null) return StatusCode(403, "You need to be a member to see online count of private chat room.");
+        }
+
+        var members = await db.ChatMembers
+            .Where(m => m.ChatRoomId == roomId)
+            .Where(m => m.LeaveAt == null)
+            .Select(m => m.AccountId)
+            .ToListAsync();
+
+        var memberStatuses = await accountsHelper.GetAccountStatusBatch(members);
+
+        var onlineCount = memberStatuses.Count(s => s.Value.IsOnline);
+
+        return Ok(onlineCount);
+    }
+
     [HttpGet("{roomId:guid}/members")]
     public async Task<ActionResult<List<SnChatMember>>> ListMembers(Guid roomId,
         [FromQuery] int take = 20,

DysonNetwork.Sphere/Chat/ChatRoomService.cs

@@ -167,20 +167,28 @@ public class ChatRoomService(
 
     public async Task SubscribeChatRoom(SnChatMember member)
     {
-        var cacheKey = ChatRoomSubscribeKeyPrefix + member.Id;
+        var cacheKey = $"{ChatRoomSubscribeKeyPrefix}{member.ChatRoomId}:{member.Id}";
         await cache.SetAsync(cacheKey, true, TimeSpan.FromHours(1));
+        await cache.AddToGroupAsync(cacheKey, $"chatroom:subscribers:{member.ChatRoomId}");
     }
 
     public async Task UnsubscribeChatRoom(SnChatMember member)
     {
-        var cacheKey = ChatRoomSubscribeKeyPrefix + member.Id;
+        var cacheKey = $"{ChatRoomSubscribeKeyPrefix}{member.ChatRoomId}:{member.Id}";
         await cache.RemoveAsync(cacheKey);
     }
 
-    public async Task<bool> IsSubscribedChatRoom(Guid memberId)
+    public async Task<bool> IsSubscribedChatRoom(Guid roomId, Guid memberId)
     {
-        var cacheKey = ChatRoomSubscribeKeyPrefix + memberId;
+        var cacheKey = $"{ChatRoomSubscribeKeyPrefix}{roomId}:{memberId}";
         var result = await cache.GetAsync<bool?>(cacheKey);
         return result ?? false;
     }
+
+    public async Task<List<Guid>> GetSubscribedMembers(Guid roomId)
+    {
+        var group = $"chatroom:subscribers:{roomId}";
+        var keys = await cache.GetGroupKeysAsync(group);
+        return keys.Select(k => Guid.Parse(k.Split(':').Last())).ToList();
+    }
 }

DysonNetwork.Sphere/Startup/BroadcastEventHandler.cs

@@ -5,6 +5,7 @@ using DysonNetwork.Shared.Proto;
 using DysonNetwork.Shared.Stream;
 using DysonNetwork.Sphere.Chat;
 using DysonNetwork.Sphere.Post;
+using Google.Protobuf;
 using Microsoft.EntityFrameworkCore;
 using NATS.Client.Core;
 using NATS.Client.JetStream.Models;
@@ -39,8 +40,9 @@ public class BroadcastEventHandler(
         var paymentTask = HandlePaymentOrders(stoppingToken);
         var accountTask = HandleAccountDeletions(stoppingToken);
         var websocketTask = HandleWebSocketPackets(stoppingToken);
+        var accountStatusTask = HandleAccountStatusUpdates(stoppingToken);
 
-        await Task.WhenAll(paymentTask, accountTask, websocketTask);
+        await Task.WhenAll(paymentTask, accountTask, websocketTask, accountStatusTask);
     }
 
     private async Task HandlePaymentOrders(CancellationToken stoppingToken)
@@ -340,6 +342,67 @@ public class BroadcastEventHandler(
         await crs.UnsubscribeChatRoom(sender);
     }
 
+    private async Task HandleAccountStatusUpdates(CancellationToken stoppingToken)
+    {
+        await foreach (var msg in nats.SubscribeAsync<byte[]>(AccountStatusUpdatedEvent.Type, cancellationToken: stoppingToken))
+        {
+            try
+            {
+                var evt = GrpcTypeHelper.ConvertByteStringToObject<AccountStatusUpdatedEvent>(ByteString.CopyFrom(msg.Data));
+                if (evt == null)
+                    continue;
+
+                logger.LogInformation("Account status updated: {AccountId}", evt.AccountId);
+
+                await using var scope = serviceProvider.CreateAsyncScope();
+                var db = scope.ServiceProvider.GetRequiredService<AppDatabase>();
+                var chatRoomService = scope.ServiceProvider.GetRequiredService<ChatRoomService>();
+
+                // Get user's joined chat rooms
+                var userRooms = await db.ChatMembers
+                    .Where(m => m.AccountId == evt.AccountId && m.LeaveAt == null)
+                    .Select(m => m.ChatRoomId)
+                    .ToListAsync(cancellationToken: stoppingToken);
+
+                // Send WebSocket packet to subscribed users per room
+                foreach (var roomId in userRooms)
+                {
+                    var members = await chatRoomService.ListRoomMembers(roomId);
+                    var subscribedMemberIds = await chatRoomService.GetSubscribedMembers(roomId);
+                    var subscribedUsers = members
+                        .Where(m => subscribedMemberIds.Contains(m.Id))
+                        .Select(m => m.AccountId.ToString())
+                        .ToList();
+
+                    if (subscribedUsers.Count == 0) continue;
+                    var packet = new WebSocketPacket
+                    {
+                        Type = "accounts.status.update",
+                        Data = new Dictionary<string, object>
+                        {
+                            ["status"] = evt.Status,
+                            ["chat_room_id"] = roomId
+                        }
+                    };
+
+                    var request = new PushWebSocketPacketToUsersRequest
+                    {
+                        Packet = packet.ToProtoValue()
+                    };
+                    request.UserIds.AddRange(subscribedUsers);
+
+                    await pusher.PushWebSocketPacketToUsersAsync(request, cancellationToken: stoppingToken);
+
+                    logger.LogInformation("Sent status update for room {roomId} to {count} subscribed users", roomId, subscribedUsers.Count);
+                }
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Error processing AccountStatusUpdated");
+            }
+        }
+    }
+
     private async Task SendErrorResponse(WebSocketPacketEvent evt, string message)
     {
         await pusher.PushWebSocketPacketToDeviceAsync(new PushWebSocketPacketToDeviceRequest