✨ Typing indicator, mark as read server-side

DysonNetwork.Sphere/Chat/ChatController.cs

@@ -18,6 +18,11 @@ public partial class ChatController(AppDatabase db, ChatService cs) : Controller
         public Guid MessageId { get; set; }
         public Guid ChatRoomId { get; set; }
     }
+    
+    public class TypingMessageRequest
+    {
+        public Guid ChatRoomId { get; set; }
+    }
 
     public class SendMessageRequest
     {

DysonNetwork.Sphere/Chat/ChatRoomController.cs

@@ -16,7 +16,8 @@ public class ChatRoomController(
     FileService fs,
     ChatRoomService crs,
     RealmService rs,
-    ActionLogService als
+    ActionLogService als,
+    NotificationService nty
 ) : ControllerBase
 {
     [HttpGet("{id:guid}")]
@@ -113,7 +114,7 @@ public class ChatRoomController(
         );
 
         var invitedMember = dmRoom.Members.First(m => m.AccountId == request.RelatedUserId);
-        await crs.SendInviteNotify(invitedMember);
+        await _SendInviteNotify(invitedMember);
 
         return Ok(dmRoom);
     }
@@ -400,7 +401,7 @@ public class ChatRoomController(
         db.ChatMembers.Add(newMember);
         await db.SaveChangesAsync();
 
-        await crs.SendInviteNotify(newMember);
+        await _SendInviteNotify(newMember);
 
         als.CreateActionLogFromRequest(
             ActionLogType.ChatroomInvite,
@@ -428,7 +429,7 @@ public class ChatRoomController(
         var chatRooms = members.Select(m => m.ChatRoom).ToList();
         var directMembers =
             (await crs.LoadDirectMessageMembers(chatRooms, userId)).ToDictionary(c => c.Id, c => c.Members);
-        
+
         foreach (var member in members.Where(member => member.ChatRoom.Type == ChatRoomType.DirectMessage))
             member.ChatRoom.Members = directMembers[member.ChatRoom.Id];
 
@@ -452,6 +453,7 @@ public class ChatRoomController(
         member.JoinedAt = NodaTime.Instant.FromDateTimeUtc(DateTime.UtcNow);
         db.Update(member);
         await db.SaveChangesAsync();
+        crs.PurgeRoomMembersCache(roomId);
 
         als.CreateActionLogFromRequest(
             ActionLogType.ChatroomJoin,
@@ -484,7 +486,7 @@ public class ChatRoomController(
     [HttpPatch("{roomId:guid}/members/{memberId:guid}/role")]
     [Authorize]
     public async Task<ActionResult<ChatMember>> UpdateChatMemberRole(Guid roomId, Guid memberId,
-        [FromBody] ChatMemberRequest request)
+        [FromBody] ChatMemberRole newRole)
     {
         if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
 
@@ -518,13 +520,13 @@ public class ChatRoomController(
                 .FirstOrDefaultAsync();
             if (targetMember is null) return NotFound();
 
-            // Check if current user has sufficient permissions
+            // Check if the current user has sufficient permissions
             if (currentMember.Role <= targetMember.Role)
                 return StatusCode(403, "You cannot modify the role of members with equal or higher roles.");
-            if (currentMember.Role <= request.Role)
+            if (currentMember.Role <= newRole)
                 return StatusCode(403, "You cannot assign a role equal to or higher than your own.");
 
-            targetMember.Role = request.Role;
+            targetMember.Role = newRole;
             db.ChatMembers.Update(targetMember);
             await db.SaveChangesAsync();
 
@@ -576,6 +578,7 @@ public class ChatRoomController(
 
             db.ChatMembers.Remove(targetMember);
             await db.SaveChangesAsync();
+            crs.PurgeRoomMembersCache(roomId);
 
             als.CreateActionLogFromRequest(
                 ActionLogType.ChatroomKick,
@@ -588,6 +591,45 @@ public class ChatRoomController(
         return BadRequest();
     }
 
+
+    [HttpPost("{roomId:guid}/members/me")]
+    [Authorize]
+    public async Task<ActionResult<ChatRoom>> JoinChatRoom(Guid roomId)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+
+        var chatRoom = await db.ChatRooms
+            .Where(r => r.Id == roomId)
+            .FirstOrDefaultAsync();
+        if (chatRoom is null) return NotFound();
+        if (!chatRoom.IsPublic)
+            return StatusCode(403, "This chat room is private. You need an invitation to join.");
+
+        var existingMember = await db.ChatMembers
+            .FirstOrDefaultAsync(m => m.AccountId == currentUser.Id && m.ChatRoomId == roomId);
+        if (existingMember != null)
+            return BadRequest("You are already a member of this chat room.");
+
+        var newMember = new ChatMember
+        {
+            AccountId = currentUser.Id,
+            ChatRoomId = roomId,
+            Role = ChatMemberRole.Member,
+            JoinedAt = NodaTime.Instant.FromDateTimeUtc(DateTime.UtcNow)
+        };
+
+        db.ChatMembers.Add(newMember);
+        await db.SaveChangesAsync();
+        crs.PurgeRoomMembersCache(roomId);
+
+        als.CreateActionLogFromRequest(
+            ActionLogType.ChatroomJoin,
+            new Dictionary<string, object> { { "chatroom_id", roomId } }, Request
+        );
+
+        return Ok(chatRoom);
+    }
+
     [HttpDelete("{roomId:guid}/members/me")]
     [Authorize]
     public async Task<ActionResult> LeaveChat(Guid roomId)
@@ -615,6 +657,7 @@ public class ChatRoomController(
 
         db.ChatMembers.Remove(member);
         await db.SaveChangesAsync();
+        crs.PurgeRoomMembersCache(roomId);
 
         als.CreateActionLogFromRequest(
             ActionLogType.ChatroomLeave,
@@ -623,4 +666,10 @@ public class ChatRoomController(
 
         return NoContent();
     }
+    
+    private async Task _SendInviteNotify(ChatMember member)
+    {
+        await nty.SendNotification(member.Account, "invites.chats", "New Chat Invitation", null,
+            $"You just got invited to join {member.ChatRoom.Name}");
+    }
 }

DysonNetwork.Sphere/Chat/ChatRoomService.cs

@@ -1,14 +1,35 @@
 using DysonNetwork.Sphere.Account;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace DysonNetwork.Sphere.Chat;
 
-public class ChatRoomService(AppDatabase db, NotificationService nty)
+public class ChatRoomService(AppDatabase db, IMemoryCache cache)
 {
-    public async Task SendInviteNotify(ChatMember member)
+    private const string RoomMembersCacheKey = "ChatRoomMembers_{0}";
+    
+    public async Task<List<ChatMember>> ListRoomMembers(Guid roomId)
     {
-        await nty.SendNotification(member.Account, "invites.chats", "New Chat Invitation", null,
+        var cacheKey = string.Format(RoomMembersCacheKey, roomId);
-            $"You just got invited to join {member.ChatRoom.Name}");
+        if (cache.TryGetValue(cacheKey, out List<ChatMember>? cachedMembers))
+            return cachedMembers!;
+    
+        var members = await db.ChatMembers
+            .Where(m => m.ChatRoomId == roomId)
+            .Where(m => m.JoinedAt != null)
+            .ToListAsync();
+    
+        var cacheOptions = new MemoryCacheEntryOptions()
+            .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));
+        cache.Set(cacheKey, members, cacheOptions);
+    
+        return members;
+    }
+    
+    public void PurgeRoomMembersCache(Guid roomId)
+    {
+        var cacheKey = string.Format(RoomMembersCacheKey, roomId);
+        cache.Remove(cacheKey);
     }
     
     public async Task<List<ChatRoom>> LoadDirectMessageMembers(List<ChatRoom> rooms, Guid userId)

DysonNetwork.Sphere/Chat/Message.cs

@@ -2,6 +2,7 @@ using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Text.Json.Serialization;
 using DysonNetwork.Sphere.Storage;
+using Microsoft.EntityFrameworkCore;
 using NodaTime;
 
 namespace DysonNetwork.Sphere.Chat;
@@ -78,6 +79,7 @@ public class MessageReaction : ModelBase
 }
 
 /// If the status is exist, means the user has read the message.
+[Index(nameof(MessageId), nameof(SenderId), IsUnique = true)]
 public class MessageStatus : ModelBase
 {
     public Guid MessageId { get; set; }

DysonNetwork.Sphere/Connection/Handlers/MessageReadHandler.cs

@@ -1,16 +1,27 @@
 using System.Net.WebSockets;
 using DysonNetwork.Sphere.Chat;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Internal;
+using SystemClock = NodaTime.SystemClock;
 
 namespace DysonNetwork.Sphere.Connection.Handlers;
 
-public class MessageReadHandler(AppDatabase db) : IWebSocketPacketHandler
+public class MessageReadHandler(AppDatabase db, IMemoryCache cache, ChatRoomService crs) : IWebSocketPacketHandler
 {
-    public string PacketType => "message.read";
+    public string PacketType => "messages.read";
 
-    public async Task HandleAsync(Account.Account currentUser, string deviceId, WebSocketPacket packet, WebSocket socket)
+    public const string ChatMemberCacheKey = "ChatMember_{0}_{1}";
+
+    public async Task HandleAsync(
+        Account.Account currentUser,
+        string deviceId,
+        WebSocketPacket packet,
+        WebSocket socket,
+        WebSocketService srv
+    )
     {
-        var request = packet.GetData<Chat.ChatController.MarkMessageReadRequest>();
+        var request = packet.GetData<ChatController.MarkMessageReadRequest>();
         if (request is null)
         {
             await socket.SendAsync(
@@ -26,12 +37,24 @@ public class MessageReadHandler(AppDatabase db) : IWebSocketPacketHandler
             return;
         }
 
-        var existingStatus = await db.ChatStatuses
+        ChatMember? sender = null;
-            .FirstOrDefaultAsync(x => x.MessageId == request.MessageId && x.Sender.AccountId == currentUser.Id);
+        var cacheKey = string.Format(ChatMemberCacheKey, currentUser.Id, request.ChatRoomId);
-        var sender = await db.ChatMembers
+        if (cache.TryGetValue(cacheKey, out ChatMember? cachedMember))
-            .Where(m => m.AccountId == currentUser.Id && m.ChatRoomId == request.ChatRoomId)
+            sender = cachedMember;
-            .FirstOrDefaultAsync();
+        else
-            
+        {
+            sender = await db.ChatMembers
+                .Where(m => m.AccountId == currentUser.Id && m.ChatRoomId == request.ChatRoomId)
+                .FirstOrDefaultAsync();
+
+            if (sender != null)
+            {
+                var cacheOptions = new MemoryCacheEntryOptions()
+                    .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));
+                cache.Set(cacheKey, sender, cacheOptions);
+            }
+        }
+
         if (sender is null)
         {
             await socket.SendAsync(
@@ -47,16 +70,25 @@ public class MessageReadHandler(AppDatabase db) : IWebSocketPacketHandler
             return;
         }
 
-        if (existingStatus == null)
+        db.ChatStatuses.Add(new MessageStatus
         {
-            existingStatus = new MessageStatus
+            MessageId = request.MessageId,
-            {
+            SenderId = sender.Id,
-                MessageId = request.MessageId,
+            ReadAt = SystemClock.Instance.GetCurrentInstant(),
-                SenderId = sender.Id,
+        });
-            };
-            db.ChatStatuses.Add(existingStatus);
-        }
 
-        await db.SaveChangesAsync();
+        try
+        {
+            await db.SaveChangesAsync();
+            
+            // Broadcast read statuses
+            var otherMembers = (await crs.ListRoomMembers(request.ChatRoomId)).Select(m => m.AccountId).ToList();
+            foreach (var member in otherMembers)
+                srv.SendPacketToAccount(member, packet);
+        }
+        catch
+        {
+            // ignored
+        }
     }
 }

DysonNetwork.Sphere/Connection/Handlers/MessageTypingHandler.cs

@@ -0,0 +1,74 @@
+using System.Net.WebSockets;
+using DysonNetwork.Sphere.Chat;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace DysonNetwork.Sphere.Connection.Handlers;
+
+public class MessageTypingHandler(AppDatabase db, ChatRoomService crs, IMemoryCache cache) : IWebSocketPacketHandler
+{
+    public string PacketType => "messages.typing";
+
+    public async Task HandleAsync(
+        Account.Account currentUser,
+        string deviceId,
+        WebSocketPacket packet,
+        WebSocket socket,
+        WebSocketService srv
+    )
+    {
+        var request = packet.GetData<ChatController.TypingMessageRequest>();
+        if (request is null)
+        {
+            await socket.SendAsync(
+                new ArraySegment<byte>(new WebSocketPacket
+                {
+                    Type = WebSocketPacketType.Error,
+                    ErrorMessage = "Mark message as read requires you provide the ChatRoomId"
+                }.ToBytes()),
+                WebSocketMessageType.Binary,
+                true,
+                CancellationToken.None
+            );
+            return;
+        }
+
+        ChatMember? sender = null;
+        var cacheKey = string.Format(MessageReadHandler.ChatMemberCacheKey, currentUser.Id, request.ChatRoomId);
+        if (cache.TryGetValue(cacheKey, out ChatMember? cachedMember))
+            sender = cachedMember;
+        else
+        {
+            sender = await db.ChatMembers
+                .Where(m => m.AccountId == currentUser.Id && m.ChatRoomId == request.ChatRoomId)
+                .FirstOrDefaultAsync();
+
+            if (sender != null)
+            {
+                var cacheOptions = new MemoryCacheEntryOptions()
+                    .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));
+                cache.Set(cacheKey, sender, cacheOptions);
+            }
+        }
+
+        if (sender is null)
+        {
+            await socket.SendAsync(
+                new ArraySegment<byte>(new WebSocketPacket
+                {
+                    Type = WebSocketPacketType.Error,
+                    ErrorMessage = "User is not a member of the chat room."
+                }.ToBytes()),
+                WebSocketMessageType.Binary,
+                true,
+                CancellationToken.None
+            );
+            return;
+        }
+
+        // Broadcast read statuses
+        var otherMembers = (await crs.ListRoomMembers(request.ChatRoomId)).Select(m => m.AccountId).ToList();
+        foreach (var member in otherMembers)
+            srv.SendPacketToAccount(member, packet);
+    }
+}

DysonNetwork.Sphere/Connection/IWebSocketPacketHandler.cs

@@ -5,5 +5,5 @@ namespace DysonNetwork.Sphere.Connection;
 public interface IWebSocketPacketHandler
 {
     string PacketType { get; }
-    Task HandleAsync(Account.Account currentUser, string deviceId, WebSocketPacket packet, WebSocket socket);
+    Task HandleAsync(Account.Account currentUser, string deviceId, WebSocketPacket packet, WebSocket socket, WebSocketService srv);
 }

DysonNetwork.Sphere/Connection/WebSocketPacket.cs

@@ -37,13 +37,17 @@ public class WebSocketPacket
     /// <returns>Deserialized data of type T</returns>
     public T? GetData<T>()
     {
-        if (Data == null)
-            return default;
         if (Data is T typedData)
             return typedData;
 
+        var jsonOpts = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
+            DictionaryKeyPolicy = JsonNamingPolicy.SnakeCaseLower,
+        };
         return JsonSerializer.Deserialize<T>(
-            JsonSerializer.Serialize(Data)
+            JsonSerializer.Serialize(Data, jsonOpts),
+            jsonOpts
         );
     }
 

DysonNetwork.Sphere/Connection/WebSocketService.cs

@@ -85,7 +85,7 @@ public class WebSocketService
     {
         if (_handlerMap.TryGetValue(packet.Type, out var handler))
         {
-            await handler.HandleAsync(currentUser, deviceId, packet, socket);
+            await handler.HandleAsync(currentUser, deviceId, packet, socket, this);
             return;
         }
 

DysonNetwork.Sphere/Migrations/20250517211759_IndexedMessageStatus.cs

@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace DysonNetwork.Sphere.Migrations
+{
+    /// <inheritdoc />
+    public partial class IndexedMessageStatus : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "ix_chat_statuses_message_id_sender_id",
+                table: "chat_statuses",
+                columns: new[] { "message_id", "sender_id" },
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "ix_chat_statuses_message_id_sender_id",
+                table: "chat_statuses");
+        }
+    }
+}

DysonNetwork.Sphere/Migrations/AppDatabaseModelSnapshot.cs

@@ -1175,6 +1175,10 @@ namespace DysonNetwork.Sphere.Migrations
                     b.HasIndex("SenderId")
                         .HasDatabaseName("ix_chat_statuses_sender_id");
 
+                    b.HasIndex("MessageId", "SenderId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_chat_statuses_message_id_sender_id");
+
                     b.ToTable("chat_statuses", (string)null);
                 });
 

DysonNetwork.Sphere/Program.cs

@@ -137,6 +137,7 @@ builder.Services.AddSingleton(tusDiskStore);
 
 // The handlers for websocket
 builder.Services.AddScoped<IWebSocketPacketHandler, MessageReadHandler>();
+builder.Services.AddScoped<IWebSocketPacketHandler, MessageTypingHandler>();
 
 // Services
 builder.Services.AddScoped<RazorViewRenderer>();