nodebb-plugin-admin-chats 1.1.0 → 2.1.0

package/library.js

@@ -2,16 +2,81 @@
 
 const User = require.main.require('./src/user');
 const Messaging = require.main.require('./src/messaging');
+const ChatsAPI = require.main.require('./src/api/chats');
 const db = require.main.require('./src/database');
+const meta = require.main.require('./src/meta');
+const privileges = require.main.require('./src/privileges');
+const helpers = require.main.require('./src/controllers/helpers');
 
 const plugin = {};
 const LOCK_PREFIX = '[admin-chat-lock]';
 const LOCKED_MESSAGE_TEXT = '🔒 חדר זה ננעל ע"י המנהלים.';
-const UNLOCKED_MESSAGE_TEXT = '🔓 חדר זה נפתח מחדש ע"י המנהלים.';
+
+async function getLockedActionMessage(uid) {
+    try {
+        const userData = await User.getUserData(uid);
+        let userLang = userData && userData.settings && userData.userLang;
+        
+        // If user doesn't have specific language setting, use forum default
+        if (!userLang) {
+            const meta = require.main.require('./src/meta');
+            userLang = meta.config.defaultLang || 'en-GB';
+        }
+        
+        if (userLang === 'he' || userLang === 'he-IL') {
+            return 'לא ניתן לבצע פעולה זו בחדר נעול';
+        } else {
+            return 'This action cannot be performed in a locked room.';
+        }
+    } catch (err) {
+        // Default to English if we can't determine language
+        return 'This action cannot be performed in a locked room.';
+    }
+}
+const ADMIN_CHAT_PAGE_SIZE = 30;
+const ADMIN_CHAT_SCAN_SIZE = 100;
 
 plugin.init = async function (params) {
-    registerRoutes(params.router, params.middleware);
+    registerRoutes(params.app, params.router, params.middleware);
     overrideMessagingFunctions();
+    overrideChatsApi();
+    overrideCoreChatRedirect(params.controllers);
+};
+
+plugin.addScripts = async function (data) {
+    let isHebrew = false;
+    
+    const uid = data.req && data.req.uid;
+    if (uid) {
+        try {
+            const userData = await User.getUserData(uid);
+            let userLang = userData && userData.settings && userData.userLang;
+            
+            // If user doesn't have specific language setting, use forum default
+            if (!userLang) {
+                const meta = require.main.require('./src/meta');
+                userLang = meta.config.defaultLang || 'en-GB';
+            }
+            
+            isHebrew = userLang === 'he' || userLang === 'he-IL';
+        } catch (err) {
+            // Default to English if error
+            isHebrew = false;
+        }
+    }
+    
+    // Only send the lockedAction translation from server
+    const translations = {
+        lockedAction: isHebrew ? 'לא ניתן לבצע פעולה זו בחדר נעול' : 'This action cannot be performed in a locked room.',
+    };
+
+    data.scripts = data.scripts || [];
+    data.scripts.push({
+        src: false,
+        script: `window.adminChatsTranslations = ${JSON.stringify(translations)};`
+    });
+
+    return data;
 };
 
 plugin.addProfileLink = async function (data) {
@@ -34,7 +99,7 @@ plugin.addProfileLink = async function (data) {
             });
         }
     } catch (e) {
-        console.error('[Super Admin Chats] Error adding profile link:', e);
+        // Silent error handling
     }
     return data;
 };
@@ -72,6 +137,49 @@ plugin.canReply = async function (payload) {
     return payload;
 };
 
+plugin.filterMessagingSend = async function (payload) {
+    const uid = getCallerUid(payload);
+    const roomId = getRoomId(payload);
+
+    if (!uid || !roomId) {
+        return payload;
+    }
+
+    if (await User.isAdministrator(uid)) {
+        return payload;
+    }
+
+    if (await isRoomLocked(roomId)) {
+        const message = await getLockedActionMessage(uid);
+        throw new Error(message);
+    }
+
+    return payload;
+};
+plugin.filterAddUsersToRoom = async function (payload) {
+    if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
+        const message = await getLockedActionMessage(payload.uid);
+        throw new Error(message);
+    }
+    return payload;
+};
+
+plugin.filterRemoveUsersFromRoom = async function (payload) {
+    if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
+        const message = await getLockedActionMessage(payload.uid);
+        throw new Error(message);
+    }
+    return payload;
+};
+
+plugin.filterRenameRoom = async function (payload) {
+    if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
+        const message = await getLockedActionMessage(payload.uid);
+        throw new Error(message);
+    }
+    return payload;
+};
+
 plugin.canGetMessages = async function (payload) {
     const isAdmin = await User.isAdministrator(payload.callerUid);
     if (isAdmin) {
@@ -104,11 +212,12 @@ plugin.onLoadRoom = async function (payload) {
 
     const isAdmin = await User.isAdministrator(uid);
     const lockData = await getRoomLockData(room.roomId);
-    room.adminChatLock = lockData;
+    const isLockedForUser = lockData.isLocked && !isAdmin;
 
-    if (lockData.isLocked) {
-        room.messages = appendLockNotice(room.messages, lockData);
-    }
+    room.adminChatLock = lockData;
+    room.messages = ensureFirstVisibleMessageHeader(buildRoomMessagesWithLockNotice(room.messages, lockData));
+    room.canReply = room.canReply && !isLockedForUser;
+    room.showUserInput = room.showUserInput && !isLockedForUser;
 
     if (!isAdmin) {
         return payload;
@@ -138,16 +247,26 @@ plugin.onLoadRoom = async function (payload) {
                 msg.index = count - index - 1;
             });
 
-            room.messages = appendLockNotice(messages.reverse(), lockData);
+            room.messages = ensureFirstVisibleMessageHeader(buildRoomMessagesWithLockNotice(messages.reverse(), lockData));
 
             room.messages.forEach((msg, index) => {
                 if (index === 0) {
                     msg.newSet = true;
                 } else {
                     const prevMsg = room.messages[index - 1];
-                    msg.newSet = parseInt(msg.fromuid, 10) !== parseInt(prevMsg.fromuid, 10);
+                    const prevTime = parseInt(prevMsg && prevMsg.timestamp, 10) || 0;
+                    const currentTime = parseInt(msg && msg.timestamp, 10) || 0;
+
+                    msg.newSet = !!(
+                        currentTime > prevTime + Messaging.newMessageCutoff ||
+                        parseInt(msg.fromuid, 10) !== parseInt(prevMsg.fromuid, 10) ||
+                        prevMsg.system ||
+                        msg.toMid
+                    );
                 }
             });
+
+            room.messages = ensureFirstVisibleMessageHeader(room.messages);
         }
 
         room.isAdmin = true;
@@ -158,6 +277,43 @@ plugin.onLoadRoom = async function (payload) {
     return payload;
 };
 
+function overrideCoreChatRedirect(controllers) {
+    const chatsController = controllers && controllers.accounts && controllers.accounts.chats;
+    if (!chatsController || typeof chatsController.redirectToChat !== 'function' || chatsController.redirectToChat._adminChatsWrapped) {
+        return;
+    }
+
+    const originalRedirectToChat = chatsController.redirectToChat;
+    const wrappedRedirectToChat = async function (req, res, next) {
+        if (req && req.uid && await User.isAdministrator(req.uid)) {
+            return await renderAdminChatsPage(req, res, next);
+        }
+
+        return await originalRedirectToChat.call(this, req, res, next);
+    };
+
+    wrappedRedirectToChat._adminChatsWrapped = true;
+    chatsController.redirectToChat = wrappedRedirectToChat;
+}
+
+function overrideChatsApi() {
+    if (!ChatsAPI || typeof ChatsAPI.kick !== 'function' || ChatsAPI.kick._adminChatLockWrapped) {
+        return;
+    }
+
+    const originalKick = ChatsAPI.kick;
+    const wrappedKick = async function (caller, data) {
+        if (caller && !await User.isAdministrator(caller.uid) && data && data.roomId && Array.isArray(data.uids) && data.uids.length === 1 && parseInt(data.uids[0], 10) === parseInt(caller.uid, 10) && await isRoomLocked(data.roomId)) {
+            const message = await getLockedActionMessage(caller.uid);
+            throw new Error(message);
+        }
+
+        return await originalKick.call(this, caller, data);
+    };
+
+    wrappedKick._adminChatLockWrapped = true;
+    ChatsAPI.kick = wrappedKick;
+}
 function overrideMessagingFunctions() {
     const originalCanEdit = Messaging.canEdit;
     const originalCanDelete = Messaging.canDelete;
@@ -168,6 +324,13 @@ function overrideMessagingFunctions() {
         if (await User.isAdministrator(uid)) {
             return true;
         }
+
+        const roomId = await getMessageRoomId(messageId);
+        if (roomId && await isRoomLocked(roomId)) {
+            const message = await getLockedActionMessage(uid);
+            throw new Error(message);
+        }
+
         return await originalCanEdit(messageId, uid);
     };
 
@@ -175,6 +338,13 @@ function overrideMessagingFunctions() {
         if (await User.isAdministrator(uid)) {
             return true;
         }
+
+        const roomId = await getMessageRoomId(messageId);
+        if (roomId && await isRoomLocked(roomId)) {
+            const message = await getLockedActionMessage(uid);
+            throw new Error(message);
+        }
+
         return await originalCanDelete(messageId, uid);
     };
 
@@ -197,9 +367,9 @@ function overrideMessagingFunctions() {
             return await originalCanReply.apply(this, args);
         };
     }
-};
+}
 
-function registerRoutes(router, middleware) {
+function registerRoutes(app, router, middleware) {
     if (!router) {
         return;
     }
@@ -209,6 +379,56 @@ function registerRoutes(router, middleware) {
         routeMiddleware.push(middleware.ensureLoggedIn);
     }
 
+    const pageMiddlewares = [
+        middleware.autoLocale,
+        middleware.applyBlacklist,
+        middleware.authenticateRequest,
+        middleware.redirectToHomeIfBanned,
+        middleware.maintenanceMode,
+        middleware.registrationComplete,
+        middleware.pluginHooks,
+        ...routeMiddleware,
+        middleware.pageView,
+    ].filter(Boolean);
+
+    const pageController = async (req, res, next) => {
+        try {
+            await renderAdminChatsPage(req, res, next);
+        } catch (err) {
+            next(err);
+        }
+    };
+
+    const pageRouter = app || router;
+    pageRouter.get('/chats/:roomId?/:index?', middleware.busyCheck, pageMiddlewares, middleware.buildHeader, pageController);
+
+    router.get('/api/admin-chats', ...routeMiddleware, async (req, res) => {
+        try {
+            if (!await assertAdminChatsAccess(req, res)) {
+                return;
+            }
+
+            const start = Math.max(0, parseInt(req.query.start, 10) || 0);
+            const data = await getAdminRecentChats(req.uid, start, 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)) {
+                return;
+            }
+
+            const payload = await buildAdminChatsPayload(req);
+            res.json(payload);
+        } catch (err) {
+            res.status(500).json({ status: { code: 'error', message: err.message } });
+        }
+    });
+
     router.post('/api/admin-chats/:roomId/lock', ...routeMiddleware, async (req, res) => {
         try {
             const actingUid = req.uid;
@@ -237,12 +457,248 @@ function registerRoutes(router, middleware) {
                 lockData,
             });
         } catch (err) {
-            console.error('[Super Admin Chats] Error updating room lock:', err);
             return res.status(500).json({ status: { code: 'error', message: err.message } });
         }
     });
 }
 
+async function renderAdminChatsPage(req, res, next) {
+    if (meta.config.disableChat) {
+        return next();
+    }
+
+    if (!await assertAdminChatsAccess(req, res)) {
+        return;
+    }
+
+    const payload = await buildAdminChatsPayload(req);
+    if (req.params.roomId && !payload.roomId) {
+        return next();
+    }
+
+    res.render('chats', payload);
+}
+
+async function assertAdminChatsAccess(req, res) {
+    if (!req.uid || !await User.isAdministrator(req.uid)) {
+        helpers.notAllowed(req, res);
+        return false;
+    }
+
+    return true;
+}
+
+async function buildAdminChatsPayload(req) {
+    const userslug = await User.getUserField(req.uid, 'userslug');
+    const [recentChats, publicRooms, privateRoomCount] = await Promise.all([
+        getAdminRecentChats(req.uid, 0, ADMIN_CHAT_PAGE_SIZE),
+        Messaging.getPublicRooms(req.uid, req.uid),
+        getPrivateRoomCount(),
+    ]);
+
+    const payload = {
+        title: '[[pages:chats]]',
+        uid: req.uid,
+        userslug,
+        adminAllChats: true,
+        rooms: recentChats.rooms,
+        nextStart: recentChats.nextStart,
+        publicRooms: publicRooms || [],
+        privateRoomCount,
+        bodyClasses: ['page-user-chats'],
+    };
+
+    const roomId = parseInt(req.params.roomId, 10) || 0;
+    if (!roomId) {
+        return payload;
+    }
+
+    const roomPayload = await buildAdminChatRoomPayload(req.uid, roomId, req.params.index);
+    if (!roomPayload) {
+        return payload;
+    }
+
+    return {
+        ...payload,
+        ...roomPayload,
+    };
+}
+
+async function buildAdminChatRoomPayload(uid, roomId, indexParam) {
+    let start = 0;
+    let scrollToIndex = null;
+
+    if (indexParam) {
+        const msgCount = await db.getObjectField(`chat:room:${roomId}`, 'messageCount');
+        start = Math.max(0, parseInt(msgCount, 10) - parseInt(indexParam, 10) - 49);
+        scrollToIndex = Math.min(msgCount, Math.max(0, parseInt(indexParam, 10) || 1));
+    }
+
+    const room = await Messaging.loadRoom(uid, {
+        uid,
+        roomId,
+        start,
+    });
+
+    if (!room) {
+        return null;
+    }
+
+    const [canViewInfo, canUploadImage, canUploadFile] = await privileges.global.can([
+        'view:users:info', 'upload:post:image', 'upload:post:file',
+    ], uid);
+
+    room.title = room.roomName || room.usernames || '[[pages:chats]]';
+    room.bodyClasses = ['page-user-chats', 'chat-loaded'];
+    room.canViewInfo = canViewInfo;
+    room.canUpload = (canUploadImage || canUploadFile) && (meta.config.maximumFileSize > 0 || room.isAdmin);
+    room.scrollToIndex = scrollToIndex;
+
+    return room;
+}
+
+async function getPrivateRoomCount() {
+    const [totalCount, publicCount] = await Promise.all([
+        db.sortedSetCard('chat:rooms'),
+        db.sortedSetCard('chat:rooms:public'),
+    ]);
+
+    return Math.max(0, (parseInt(totalCount, 10) || 0) - (parseInt(publicCount, 10) || 0));
+}
+
+async function getAdminRecentChats(uid, start, limit) {
+    let cursor = Math.max(0, parseInt(start, 10) || 0);
+    const roomPairs = [];
+
+    while (roomPairs.length < limit) {
+        const roomIds = await db.getSortedSetRevRange('chat:rooms', cursor, cursor + ADMIN_CHAT_SCAN_SIZE - 1);
+        if (!roomIds.length) {
+            break;
+        }
+
+        const rooms = await Messaging.getRoomsData(roomIds);
+        rooms.forEach((room, index) => {
+            if (room && !room.public && roomPairs.length < limit) {
+                roomPairs.push({
+                    roomId: roomIds[index],
+                    room,
+                });
+            }
+        });
+
+        cursor += roomIds.length;
+        if (roomIds.length < ADMIN_CHAT_SCAN_SIZE) {
+            break;
+        }
+    }
+
+    const rooms = roomPairs.map(item => item.room);
+    const roomIds = roomPairs.map(item => item.roomId);
+
+    await enrichAdminRecentRooms(uid, roomIds, rooms);
+
+    return {
+        rooms,
+        nextStart: cursor,
+    };
+}
+
+async function enrichAdminRecentRooms(uid, roomIds, rooms) {
+    if (!roomIds.length) {
+        return;
+    }
+
+    const roomUsers = await Promise.all(roomIds.map(roomId => Messaging.getUidsInRoom(roomId, 0, -1)));
+    const uniqueUids = [...new Set(roomUsers.flat().filter(Boolean))];
+    const userMap = new Map();
+
+    if (uniqueUids.length) {
+        const users = await User.getUsersFields(uniqueUids, [
+            'uid', 'username', 'userslug', 'displayname', 'picture', 'status', 'lastonline',
+        ]);
+        uniqueUids.forEach((memberUid, index) => {
+            const userData = users[index];
+            if (userData) {
+                userData.status = User.getStatus(userData);
+                userMap.set(String(memberUid), userData);
+            }
+        });
+    }
+
+    const teasers = await Promise.all(roomIds.map(roomId => getAdminRoomTeaser(roomId)));
+
+    rooms.forEach((room, index) => {
+        if (!room) {
+            return;
+        }
+
+        room.users = (roomUsers[index] || [])
+            .map(memberUid => userMap.get(String(memberUid)))
+            .filter(Boolean);
+        room.groupChat = room.userCount > 2;
+        room.unread = false;
+        room.teaser = teasers[index];
+        room.lastUser = room.users[0];
+        room.usernames = Messaging.generateUsernames(room, uid);
+        room.participantsLabel = buildParticipantsLabel(room.users);
+        room.icon = Messaging.getRoomIcon(room);
+    });
+}
+
+function buildParticipantsLabel(users) {
+    const list = Array.isArray(users) ? users.filter(Boolean) : [];
+    if (!list.length) {
+        return '';
+    }
+
+    const names = list.map(user => user.displayname || user.username).filter(Boolean);
+    if (names.length <= 5) {
+        return names.join(', ');
+    }
+
+    return `${names.slice(0, 5).join(', ')} +${names.length - 5}`;
+}
+
+async function getAdminRoomTeaser(roomId) {
+    const mids = await db.getSortedSetRevRange(`chat:room:${roomId}:mids`, 0, 19);
+    if (!mids.length) {
+        return null;
+    }
+
+    const teaser = (await Messaging.getMessagesFields(mids, ['fromuid', 'content', 'timestamp', 'deleted', 'system']))
+        .find(message => message && !message.deleted && !message.system && message.fromuid);
+
+    if (!teaser) {
+        return null;
+    }
+
+    const teaserUser = await User.getUserFields(teaser.fromuid, [
+        'uid', 'username', 'userslug', 'displayname', 'picture', 'status', 'lastonline',
+    ]);
+
+    if (teaserUser) {
+        teaser.user = teaserUser;
+    }
+
+    teaser.content = String(teaser.content || '')
+        .replace(/<[^>]*>/g, '')
+        .trim();
+    teaser.roomId = roomId;
+
+    return teaser;
+}
+
+async function canNonAdminModifyLockedRoom(uid, roomId) {
+    if (!uid || !roomId) {
+        return false;
+    }
+
+    if (await User.isAdministrator(uid)) {
+        return false;
+    }
+
+    return await isRoomLocked(roomId);
+}
 async function roomExists(roomId) {
     const roomData = await db.getObject(`chat:room:${roomId}`);
     return !!roomData;
@@ -256,7 +712,6 @@ async function lockRoom(roomId, actingUid) {
         lockedAt: now,
     });
 
-    await addLockSystemMessage(roomId, actingUid, true);
     return await getRoomLockData(roomId);
 }
 
@@ -267,29 +722,19 @@ async function unlockRoom(roomId, actingUid) {
         lockedAt: 0,
     });
 
-    await addLockSystemMessage(roomId, actingUid, false);
     return await getRoomLockData(roomId);
 }
 
-async function addLockSystemMessage(roomId, actingUid, isLocked) {
-    if (typeof Messaging.addSystemMessage !== 'function') {
-        return;
-    }
-
-    const messageText = isLocked ? LOCK_PREFIX + ' ' + LOCKED_MESSAGE_TEXT : LOCK_PREFIX + ' ' + UNLOCKED_MESSAGE_TEXT;
-
-    try {
-        await Messaging.addSystemMessage(messageText, actingUid, roomId);
-    } catch (err) {
-        console.error('[Super Admin Chats] Error adding lock system message:', err);
-    }
-}
-
 async function isRoomLocked(roomId) {
     const field = await db.getObjectField(`chat:room:${roomId}:adminLock`, 'isLocked');
     return field === '1' || field === 1 || field === true;
 }
 
+async function getMessageRoomId(messageId) {
+    const roomId = await db.getObjectField(`message:${messageId}`, 'roomId');
+    return parseInt(roomId, 10) || 0;
+}
+
 async function getRoomLockData(roomId) {
     const data = await db.getObject(`chat:room:${roomId}:adminLock`) || {};
     const lockedBy = parseInt(data.lockedBy, 10) || 0;
@@ -303,20 +748,25 @@ async function getRoomLockData(roomId) {
     };
 }
 
-function appendLockNotice(messages, lockData) {
+function ensureFirstVisibleMessageHeader(messages) {
     const list = Array.isArray(messages) ? messages.slice() : [];
-    if (!lockData || !lockData.isLocked || !lockData.lockedAt) {
-        return list;
+    const firstUserMessageIndex = list.findIndex(msg => msg && !msg.system);
+
+    if (firstUserMessageIndex !== -1) {
+        list[firstUserMessageIndex].newSet = true;
     }
 
-    const content = `${LOCK_PREFIX} ${LOCKED_MESSAGE_TEXT}`;
-    const exists = list.some(msg => msg && msg.content === content);
-    if (exists) {
-        return list;
+    return list;
+}
+
+function buildRoomMessagesWithLockNotice(messages, lockData) {
+    const cleanedMessages = stripAdminLockMessages(messages);
+    if (!lockData || !lockData.isLocked || !lockData.lockedAt) {
+        return cleanedMessages;
     }
 
-    list.push({
-        content,
+    cleanedMessages.push({
+        content: `${LOCK_PREFIX} ${LOCKED_MESSAGE_TEXT}`,
         fromuid: lockData.lockedBy,
         uid: lockData.lockedBy,
         timestamp: lockData.lockedAt,
@@ -325,13 +775,26 @@ function appendLockNotice(messages, lockData) {
         newSet: true,
     });
 
-    list.sort((left, right) => {
+    cleanedMessages.sort((left, right) => {
         const leftTime = parseInt(left && (left.timestamp || left.datetime), 10) || 0;
         const rightTime = parseInt(right && (right.timestamp || right.datetime), 10) || 0;
         return leftTime - rightTime;
     });
 
-    return list;
+    return cleanedMessages;
+}
+
+function stripAdminLockMessages(messages) {
+    const list = Array.isArray(messages) ? messages.slice() : [];
+    return list.filter(msg => !isAdminLockMessage(msg));
+}
+
+function isAdminLockMessage(msg) {
+    const content = String(msg && msg.content || '');
+    return content.includes('admin-chat-lock') ||
+        content.includes(LOCKED_MESSAGE_TEXT) ||
+        content.includes('נפתח מחדש ע"י המנהלים') ||
+        content.includes('modules:chat.system.[admin-chat-lock]');
 }
 
 function guessRoomIdUidFromArgs(args) {
@@ -370,3 +833,4 @@ function getRoomId(payload) {
 }
 
 module.exports = plugin;
+

package/package.json

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