nodebb-plugin-admin-chats 3.8.1 → 3.8.3

package/lib/hooks.js

@@ -243,7 +243,11 @@ hooks.onLoadRoom = async function (payload) {
         isLockedForUser
     );
     room.canReply = room.canReply && !isLockedForUser;
-    room.showUserInput = room.showUserInput && !isLockedForUser;
+    // The composer in partials/chats/message-window.tpl is wrapped in {{{ if showUserInput }}}.
+    // Core sets showUserInput = false whenever "maximum users in chat room" is 2 (the flag was
+    // meant for the add-user field and core templates no longer use it), which hid the message
+    // box on /chats - the page phones use. Only hide it when the room is locked for the viewer.
+    room.showUserInput = !isLockedForUser;
 
     if (!hasAccess) {
         return payload;

package/lib/overrides.js

@@ -16,6 +16,7 @@ const {
 const { isRoomLocked } = require('./lock');
 const { editHistoryKey } = require('./history');
 const privileges = nodebb.require('./src/privileges');
+const helpers = nodebb.require('./src/controllers/helpers');
 
 // NodeBB translates `[[namespace:key]]` error messages itself (both in
 // app.alertError on the client and anywhere else the message surfaces) —
@@ -46,6 +47,45 @@ function overrideCoreChatRedirect(controllers, renderAdminChatsPage) {
     chatsController.redirectToChat = wrappedRedirectToChat;
 }
 
+// /user/<slug>/chats/<roomId> renders the room as seen by <slug>: core loads
+// its messages from that user's join timestamp, so for a private room the
+// user is not in it comes out empty (title only). Send the viewer to a URL
+// that can actually show the room — their own chats page if they are in it,
+// otherwise the all-chats page.
+function overrideCoreChatsPage(controllers) {
+    const chatsController = controllers && controllers.accounts && controllers.accounts.chats;
+    if (!chatsController || typeof chatsController.get !== 'function' || chatsController.get._adminChatsWrapped) {
+        return;
+    }
+
+    const originalGet = chatsController.get;
+    const wrappedGet = async function (req, res, next) {
+        const roomId = parseInt(req.params.roomid, 10);
+        const isSwitch = res.locals.isAPI && parseInt(req.query.switch, 10) === 1;
+        if (roomId && !isSwitch && req.uid && await canAccessAdminChats(req.uid)) {
+            const uid = await User.getUidByUserslug(req.params.userslug);
+            if (uid && parseInt(uid, 10) !== parseInt(req.uid, 10)) {
+                const [room, isOwnerInRoom, isCallerInRoom] = await Promise.all([
+                    Messaging.getRoomData(roomId),
+                    isUserMemberOfRoom(uid, roomId),
+                    isUserMemberOfRoom(req.uid, roomId),
+                ]);
+                if (room && !room.public && !isOwnerInRoom) {
+                    const index = parseInt(req.params.index, 10);
+                    const suffix = `${roomId}${index ? `/${index}` : ''}`;
+                    const callerSlug = isCallerInRoom && await User.getUserField(req.uid, 'userslug');
+                    return helpers.redirect(res, callerSlug ? `/user/${callerSlug}/chats/${suffix}` : `/chats/${suffix}`);
+                }
+            }
+        }
+
+        return await originalGet.call(this, req, res, next);
+    };
+
+    wrappedGet._adminChatsWrapped = true;
+    chatsController.get = wrappedGet;
+}
+
 function overrideChatsApi() {
     if (!ChatsAPI || typeof ChatsAPI.kick !== 'function' || ChatsAPI.kick._adminChatLockWrapped) {
         return;
@@ -181,6 +221,7 @@ function overrideMessagingFunctions() {
 module.exports = {
     getMessageRoomId,
     overrideCoreChatRedirect,
+    overrideCoreChatsPage,
     overrideChatsApi,
     overrideMessagingFunctions,
 };

package/lib/routes.js

@@ -14,6 +14,7 @@ const { roomExists, lockRoom, unlockRoom, getRoomLockData } = require('./lock');
 const { ACTIVITY_SET, pruneActivityEntries } = require('./activity');
 
 const ADMIN_CHAT_PAGE_SIZE = 30;
+const ADMIN_CHAT_SEARCH_LIMIT = 100;
 
 async function assertAdminChatsAccess(req, res) {
     if (!req.uid || !await canAccessAdminChats(req.uid)) {
@@ -202,6 +203,41 @@ async function enrichAdminRecentRooms(uid, roomIds, rooms) {
     });
 }
 
+async function searchAdminChats(uid, query) {
+    const lowerQuery = String(query).toLowerCase();
+    const allRoomIds = await db.getSortedSetRevRange(ACTIVITY_SET, 0, -1);
+    const [allRooms, roomUids] = await Promise.all([
+        Messaging.getRoomsData(allRoomIds, ['roomName', 'public']),
+        db.getSortedSetsMembers(allRoomIds.map(roomId => `chat:room:${roomId}:uids`)),
+    ]);
+
+    const uniqueUids = [...new Set(roomUids.flat().filter(Boolean))];
+    const users = await User.getUsersFields(uniqueUids, ['username', 'displayname']);
+    const matchingUids = new Set();
+    users.forEach((user, index) => {
+        if (user && (
+            (user.displayname && user.displayname.toLowerCase().includes(lowerQuery)) ||
+            (user.username && user.username.toLowerCase().includes(lowerQuery))
+        )) {
+            matchingUids.add(String(uniqueUids[index]));
+        }
+    });
+
+    const roomIds = allRoomIds.filter((roomId, index) => {
+        const room = allRooms[index];
+        if (!room || room.public) {
+            return false;
+        }
+        return (room.roomName && room.roomName.toLowerCase().includes(lowerQuery)) ||
+            (roomUids[index] || []).some(memberUid => matchingUids.has(String(memberUid)));
+    }).slice(0, ADMIN_CHAT_SEARCH_LIMIT);
+
+    const rooms = await Messaging.getRoomsData(roomIds);
+    await enrichAdminRecentRooms(uid, roomIds, rooms);
+
+    return { rooms: rooms.filter(Boolean) };
+}
+
 function buildParticipantsLabel(users) {
     const list = Array.isArray(users) ? users.filter(Boolean) : [];
     if (!list.length) {
@@ -308,6 +344,33 @@ function registerRoutes(app, router, middleware) {
         }
     });
 
+    // Core's chat list search (GET /api/v3/chats/search) always searches the
+    // caller's own rooms, so on the all-chats page and on another user's chats
+    // page it would list the viewer's chats instead of the ones being viewed.
+    router.get('/api/admin-chats/search', ...routeMiddleware, async (req, res) => {
+        try {
+            if (!await assertAdminChatsAccess(req, res)) {
+                return;
+            }
+
+            const query = String(req.query.query || '').trim();
+            const uid = parseInt(req.query.uid, 10) || 0;
+            let data;
+            if (uid) {
+                data = query ?
+                    await Messaging.searchRecentChats(req.uid, uid, query) :
+                    await Messaging.getRecentChats(req.uid, uid, 0, ADMIN_CHAT_PAGE_SIZE - 1);
+            } else {
+                data = query ?
+                    await searchAdminChats(req.uid, query) :
+                    await getAdminRecentChats(req.uid, 0, ADMIN_CHAT_PAGE_SIZE);
+            }
+            res.json(data);
+        } catch (err) {
+            res.status(500).json({ status: { code: 'error', message: err.message } });
+        }
+    });
+
     router.get('/api/admin-chats/page/:roomId?/:index?', ...routeMiddleware, async (req, res) => {
         try {
             if (!await assertAdminChatsAccess(req, res)) {

package/library.js

@@ -2,7 +2,7 @@
 
 const hooks = require('./lib/hooks');
 const { registerRoutes, renderAdminChatsPage } = require('./lib/routes');
-const { overrideMessagingFunctions, overrideChatsApi, overrideCoreChatRedirect } = require('./lib/overrides');
+const { overrideMessagingFunctions, overrideChatsApi, overrideCoreChatRedirect, overrideCoreChatsPage } = require('./lib/overrides');
 const { overrideForActivityTracking, backfillActivitySet } = require('./lib/activity');
 
 const plugin = Object.assign({}, hooks);
@@ -12,6 +12,7 @@ plugin.init = async function (params) {
     overrideMessagingFunctions();
     overrideChatsApi();
     overrideCoreChatRedirect(params.controllers, renderAdminChatsPage);
+    overrideCoreChatsPage(params.controllers);
     overrideForActivityTracking();
     await backfillActivitySet();
 };

package/package.json

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

package/plugin.json

@@ -11,7 +11,8 @@
     "static/lib/delete-room.js",
     "static/lib/live-updates.js",
     "static/lib/profile-link.js",
-    "static/lib/message-history.js"
+    "static/lib/message-history.js",
+    "static/lib/chat-search.js"
   ],
   "hooks": [
     {

package/static/lib/chat-search.js

@@ -0,0 +1,80 @@
+'use strict';
+
+// Core's chat list search (public/src/client/chats/search.js) always searches
+// the caller's own rooms. On the admin all-chats page and on another user's
+// chats page that lists the viewer's chats instead of the ones on screen, and
+// opening one of them lands on /user/<other>/chats/<roomId> for a room that
+// user is not in. Core binds its listener with no handle to remove it, so the
+// input is swapped for a clone and searched through the plugin's endpoint.
+$(document).ready(function () {
+    function getSearchUid() {
+        const data = ajaxify && ajaxify.data;
+        if (!data) {
+            return null;
+        }
+        if (data.adminAllChats) {
+            return 0;
+        }
+        const uid = parseInt(data.uid, 10) || 0;
+        if (!uid || uid === parseInt(app.user.uid, 10)) {
+            return null;
+        }
+        return uid;
+    }
+
+    async function search(query, uid) {
+        const params = new URLSearchParams({ query });
+        if (uid) {
+            params.set('uid', uid);
+        }
+        const response = await fetch(`${config.relative_path || ''}/api/admin-chats/search?${params.toString()}`, {
+            credentials: 'same-origin',
+        });
+        if (!response.ok) {
+            throw new Error(`Received ${response.status}`);
+        }
+        return await response.json();
+    }
+
+    function takeOverSearch() {
+        const uid = getSearchUid();
+        const searchEl = document.getElementById('search-chats');
+        const listEl = document.getElementById('private-rooms');
+        if (uid === null || !searchEl || !listEl || searchEl.hasAttribute('data-admin-chats-search')) {
+            return;
+        }
+
+        const replacement = searchEl.cloneNode(true);
+        replacement.value = searchEl.value;
+        replacement.setAttribute('data-admin-chats-search', '1');
+        searchEl.replaceWith(replacement);
+
+        let lastQuery = replacement.value.trim();
+        replacement.addEventListener('keyup', utils.debounce(async function () {
+            const query = replacement.value.trim();
+            if (query === lastQuery) {
+                return;
+            }
+            lastQuery = query;
+            try {
+                const data = await search(query, uid);
+                if (query !== lastQuery) {
+                    return;
+                }
+                const html = await app.parseAndTranslate('chats', 'rooms', data);
+                $(listEl).html(html);
+                html.find('.timeago').timeago();
+                listEl.setAttribute('data-nextstart', data.nextStart || 0);
+                listEl.setAttribute('data-prevstart', 0);
+                // Both infinite-scroll loaders (core's and switch-chat.js) bail out
+                // while `loading` is set; keep them from appending the unfiltered
+                // list under the search results.
+                listEl.toggleAttribute('loading', !!query);
+            } catch (err) {
+                app.alertError(err);
+            }
+        }, 300));
+    }
+
+    $(window).on('action:chat.loaded', takeOverSearch);
+});

package/static/lib/switch-chat.js

@@ -192,6 +192,12 @@ $(document).ready(function () {
         if (!isAdminAllChatsPage()) {
             return;
         }
+        // On back/forward away from the chats page ajaxify.data still describes the chats
+        // page until the next page finishes loading. Without this check the room list is
+        // "switched" to and /chats is pushed on top of the page the user is navigating to.
+        if (!/\/chats(\/|$)/.test(window.location.pathname)) {
+            return;
+        }
 
         const urlMatch = window.location.pathname.match(/\/chats\/(\d+)/);
         const urlRoomId = urlMatch ? parseInt(urlMatch[1], 10) : 0;