nodebb-plugin-admin-chats 3.8.2 → 3.8.4

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,46 @@ 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. This includes the viewer's own slug: an admin
+// reading a room they are not in must stay on 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) {
+                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 +222,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.2",
+  "version": "3.8.4",
   "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

@@ -215,6 +215,48 @@ $(document).ready(function () {
         });
     }
 
+    // Core's chat scroll handler (updateUrlWithMessageIndex) always rewrites the
+    // address to user/<viewer-slug>/chats/<roomId>/<index>. On the all-chats page
+    // the viewer is usually not in the room, and that URL renders the room from
+    // the viewer's (missing) join timestamp — so a reload/back landed on a room
+    // that could not scroll past the first batch. Keep the admin URL scheme.
+    function patchReplaceStateForAdminAll() {
+        if (!history.replaceState || history.replaceState._adminAllChatsPatched) {
+            return;
+        }
+
+        const originalReplaceState = history.replaceState;
+        const patchedReplaceState = function (state, title, url) {
+            const userslug = ajaxify && ajaxify.data && ajaxify.data.userslug;
+            if (isAdminAllChatsPage() && userslug && typeof url === 'string') {
+                const prefix = `${config.relative_path || ''}/user/${userslug}/chats/`;
+                const parsed = new URL(url, window.location.href);
+                // Non-ASCII slugs come back percent-encoded in URL#pathname
+                let pathname = parsed.pathname;
+                try {
+                    pathname = decodeURIComponent(pathname);
+                } catch (err) {
+                    // keep the raw pathname
+                }
+                const match = pathname.startsWith(prefix) &&
+                    pathname.slice(prefix.length).match(/^(\d+(?:\/\d+)?)$/);
+                if (match) {
+                    const newUrl = getAdminChatsPageUrl(match[1]);
+                    parsed.pathname = `${config.relative_path || ''}/${newUrl}`;
+                    url = parsed.href;
+                    if (state && typeof state.url === 'string') {
+                        state = { ...state, url: newUrl + parsed.search };
+                    }
+                }
+            }
+            return originalReplaceState.call(this, state, title, url);
+        };
+        patchedReplaceState._adminAllChatsPatched = true;
+        history.replaceState = patchedReplaceState;
+    }
+
+    patchReplaceStateForAdminAll();
+
     $(window).on('action:ajaxify.end', function (ev, data) {
         if (isAdminAllChatsPage()) {
             patchForumChatsForAdminAll();