nodebb-plugin-admin-chats 3.1.2 → 3.3.0

package/client.js

@@ -336,68 +336,69 @@ $(document).ready(function() {
             return null;
         }
 
+        // First, check if we have the room data in ajaxify.data (from the current page)
         const currentRoom = ajaxify && ajaxify.data && (ajaxify.data.room || ajaxify.data);
-        if (currentRoom && parseInt(currentRoom.roomId, 10) === roomId && currentRoom.adminChatLock) {
-            setCachedRoomData(roomId, currentRoom);
-            return currentRoom;
+        if (currentRoom && parseInt(currentRoom.roomId, 10) === roomId) {
+            if (currentRoom.adminChatLock) {
+                setCachedRoomData(roomId, currentRoom);
+                return currentRoom;
+            }
         }
 
+        // Check cache
         const cached = getCachedRoomData(roomId);
         if (cached) {
             return cached;
         }
 
-        const endpoint = isAdminAllChatsPage() ?
-            `${config.relative_path || ''}/api/admin-chats/page/${roomId}` :
-            `${config.relative_path || ''}/api/chats/${roomId}`;
-        const response = await fetch(endpoint, {
-            headers: {
-                'x-csrf-token': config.csrf_token,
-            },
-            credentials: 'same-origin',
-        });
-        if (!response.ok) {
-            if (hasAdminChatsAccess() && !isAdminAllChatsPage()) {
-                const adminResponse = await fetch(`${config.relative_path || ''}/api/admin-chats/page/${roomId}`, {
+        // Try admin endpoint first if user has access
+        if (hasAdminChatsAccess()) {
+            const adminEndpoint = `${config.relative_path || ''}/api/admin-chats/page/${roomId}`;
+            try {
+                const adminResponse = await fetch(adminEndpoint, {
                     headers: {
                         'x-csrf-token': config.csrf_token,
                     },
                     credentials: 'same-origin',
                 });
-                if (!adminResponse.ok) {
-                    return null;
-                }
-                const adminPayload = await adminResponse.json();
-                const adminRoom = adminPayload && adminPayload.roomId ? adminPayload : (adminPayload && adminPayload.room ? adminPayload.room : null);
-                if (adminRoom) {
-                    setCachedRoomData(roomId, adminRoom);
+                if (adminResponse.ok) {
+                    const adminPayload = await adminResponse.json();
+                    const adminRoom = adminPayload && adminPayload.roomId ? adminPayload : (adminPayload && adminPayload.room ? adminPayload.room : null);
+                    if (adminRoom) {
+                        setCachedRoomData(roomId, adminRoom);
+                        return adminRoom;
+                    }
                 }
-                return adminRoom;
+            } catch (err) {
+                // Continue to fallback
             }
-            return null;
         }
 
-        const payload = await response.json();
-        const roomData = payload && payload.roomId ? payload : (payload && payload.room ? payload.room : null);
-        if (roomData && !roomData.adminChatLock && hasAdminChatsAccess() && !isAdminAllChatsPage()) {
-            const adminResponse = await fetch(`${config.relative_path || ''}/api/admin-chats/page/${roomId}`, {
+        // For all users, try to get lock data from the new endpoint
+        const lockEndpoint = `${config.relative_path || ''}/api/admin-chats/${roomId}/lock`;
+        try {
+            const lockResponse = await fetch(lockEndpoint, {
                 headers: {
                     'x-csrf-token': config.csrf_token,
                 },
                 credentials: 'same-origin',
             });
-            if (adminResponse.ok) {
-                const adminPayload = await adminResponse.json();
-                const adminRoom = adminPayload && adminPayload.roomId ? adminPayload : (adminPayload && adminPayload.room ? adminPayload.room : null);
-                if (adminRoom && adminRoom.adminChatLock) {
-                    roomData.adminChatLock = adminRoom.adminChatLock;
+            if (lockResponse.ok) {
+                const lockPayload = await lockResponse.json();
+                if (lockPayload && lockPayload.lockData) {
+                    const roomData = {
+                        roomId: roomId,
+                        adminChatLock: lockPayload.lockData,
+                    };
+                    setCachedRoomData(roomId, roomData);
+                    return roomData;
                 }
             }
+        } catch (err) {
+            // Ignore error
         }
-        if (roomData) {
-            setCachedRoomData(roomId, roomData);
-        }
-        return roomData;
+
+        return null;
     }
     function isLockedForUser(roomData) {
         return !!(roomData && roomData.adminChatLock && roomData.adminChatLock.isLocked && !canManageChats());
@@ -739,6 +740,35 @@ $(document).ready(function() {
         socket.on('event:chats.restore', function() { setTimeout(refreshChatUi, 0); });
     }
 
+    // Monitor for new chat modals/windows being added to the DOM
+    // This ensures styling is applied to floating chat windows opened from non-chat pages
+    const observer = new MutationObserver(function(mutations) {
+        let hasNewChatWindow = false;
+        mutations.forEach(function(mutation) {
+            if (mutation.type === 'childList') {
+                mutation.addedNodes.forEach(function(node) {
+                    if (node.nodeType === 1) { // Element node
+                        const $node = $(node);
+                        if ($node.is('.chat-modal') || $node.find('.chat-modal').length) {
+                            hasNewChatWindow = true;
+                        }
+                        if ($node.is('[component="chat/message/window"]') || $node.find('[component="chat/message/window"]').length) {
+                            hasNewChatWindow = true;
+                        }
+                    }
+                });
+            }
+        });
+        if (hasNewChatWindow) {
+            setTimeout(refreshChatUi, 50);
+        }
+    });
+
+    observer.observe(document.body, {
+        childList: true,
+        subtree: true
+    });
+
     // Handle browser back/forward navigation
     $(window).on('popstate', function() {
         if (isAdminAllChatsPage()) {

package/library.js

@@ -113,7 +113,6 @@ async function getLockedActionMessage(uid) {
     }
 }
 const ADMIN_CHAT_PAGE_SIZE = 30;
-const ADMIN_CHAT_SCAN_SIZE = 100;
 
 async function canAccessAdminChats(uid) {
     if (!uid) {
@@ -830,6 +829,29 @@ function registerRoutes(app, router, middleware) {
             return res.status(500).json({ status: { code: 'error', message: err.message } });
         }
     });
+
+    router.get('/api/admin-chats/:roomId/lock', ...routeMiddleware, async (req, res) => {
+        try {
+            const roomId = parseInt(req.params.roomId, 10);
+
+            if (Number.isNaN(roomId)) {
+                return res.status(400).json({ status: { code: 'bad-request', message: 'Invalid room id' } });
+            }
+
+            if (!await roomExists(roomId)) {
+                return res.status(404).json({ status: { code: 'not-found', message: 'Room not found' } });
+            }
+
+            const lockData = await getRoomLockData(roomId);
+            return res.json({
+                status: { code: 'ok', message: 'Lock data retrieved' },
+                roomId,
+                lockData,
+            });
+        } catch (err) {
+            return res.status(500).json({ status: { code: 'error', message: err.message } });
+        }
+    });
 }
 
 async function renderAdminChatsPage(req, res, next) {
@@ -947,42 +969,57 @@ async function getPrivateRoomCount() {
 }
 
 async function getAdminRecentChats(uid, start, limit) {
-    let cursor = Math.max(0, parseInt(start, 10) || 0);
-    const roomPairs = [];
+    const offset = Math.max(0, parseInt(start, 10) || 0);
+    const pageSize = Math.max(0, parseInt(limit, 10) || 0);
+    const allRoomIds = await db.getSortedSetRevRange('chat:rooms', 0, -1);
 
-    while (roomPairs.length < limit) {
-        const roomIds = await db.getSortedSetRevRange('chat:rooms', cursor, cursor + ADMIN_CHAT_SCAN_SIZE - 1);
-        if (!roomIds.length) {
-            break;
+    if (!allRoomIds.length || !pageSize) {
+        return {
+            rooms: [],
+            nextStart: offset,
+        };
+    }
+
+    const allRooms = await Messaging.getRoomsData(allRoomIds);
+    const roomPairs = (await Promise.all(allRooms.map(async (room, index) => {
+        const roomId = parseInt(allRoomIds[index], 10) || 0;
+        if (!room || room.public || !roomId) {
+            return null;
         }
 
-        const rooms = await Messaging.getRoomsData(roomIds);
-        rooms.forEach((room, index) => {
-            if (room && !room.public && roomPairs.length < limit) {
-                roomPairs.push({
-                    roomId: roomIds[index],
-                    room,
-                });
-            }
-        });
+        return {
+            roomId,
+            room,
+            lastActivity: await getAdminRoomLastActivity(roomId, room),
+        };
+    }))).filter(Boolean);
 
-        cursor += roomIds.length;
-        if (roomIds.length < ADMIN_CHAT_SCAN_SIZE) {
-            break;
-        }
-    }
+    roomPairs.sort((a, b) => (
+        b.lastActivity - a.lastActivity ||
+        b.roomId - a.roomId
+    ));
 
-    const rooms = roomPairs.map(item => item.room);
-    const roomIds = roomPairs.map(item => item.roomId);
+    const pagedRooms = roomPairs.slice(offset, offset + pageSize);
+    const rooms = pagedRooms.map(item => item.room);
+    const roomIds = pagedRooms.map(item => item.roomId);
 
     await enrichAdminRecentRooms(uid, roomIds, rooms);
 
     return {
         rooms,
-        nextStart: cursor,
+        nextStart: offset + rooms.length,
     };
 }
 
+async function getAdminRoomLastActivity(roomId, room) {
+    const lastMessage = await db.getSortedSetRevRangeWithScores(`chat:room:${roomId}:mids`, 0, 0);
+    if (lastMessage.length) {
+        return parseInt(lastMessage[0].score, 10) || 0;
+    }
+
+    return parseInt(room && room.timestamp, 10) || 0;
+}
+
 async function enrichAdminRecentRooms(uid, roomIds, rooms) {
     if (!roomIds.length) {
         return;
@@ -1225,4 +1262,3 @@ module.exports = plugin;
 
 
 
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-admin-chats",
-  "version": "3.1.2",
+  "version": "3.3.0",
   "description": "A plugin that allows the administrator to view and manage user chats.",
   "main": "library.js",
   "nbbpm": {