nodebb-plugin-admin-chats 1.0.1 → 1.1.0

package/README.md

@@ -0,0 +1,56 @@
+# Super Admin Chat Control for NodeBB
+
+A professional administration plugin for NodeBB that allows administrators to monitor, manage, and interact with any chat room on the forum, regardless of membership.
+
+## Main Features
+
+* **Global Chat Access**: Administrators can view any private or group conversation.
+* **Management Privileges**: Grants admins the ability to edit or delete any message in any room.
+* **Admin Room Locking**: Administrators can lock any chat room so only admins can continue replying.
+* **Profile Integration**: Adds a "View Chats" button to the user profile menu for administrators to quickly audit a user's interactions.
+* **Non-Intrusive Monitoring**: Admins can load and view room history without being added as permanent members, maintaining a clean member list.
+* **UI Enhancements**: Replaces generic "no chats" messages with helpful instructions for admins and supports both English and Hebrew interfaces.
+
+## Technical Overview
+
+### Plugin Information
+* **Name**: Super Admin Chat Control
+* **ID**: `nodebb-plugin-admin-chats`
+* **Compatibility**: NodeBB versions `^3.0.0` or `^4.0.0`
+
+### Implemented Hooks
+The plugin utilizes several filters to elevate administrator permissions:
+
+| Hook | Method | Functionality |
+| :--- | :--- | :--- |
+| `filter:messaging.isRoomOwner` | `isRoomOwner` | Treats admins as owners for permission checks. |
+| `filter:messaging.canReply` | `canReply` | Allows admins to send messages in any room and blocks regular users in admin-locked rooms. |
+| `filter:messaging.canGetMessages` | `canGetMessages` | Allows admins to fetch chat history. |
+| `filter:messaging.loadRoom` | `onLoadRoom` | Manages room loading logic for non-member admins and injects lock state. |
+| `filter:user.accountMenu` | `addProfileLink` | Injects the admin link into the profile menu. |
+
+### Function Overrides
+The plugin overrides core messaging functions to ensure full administrative control:
+* **Edit/Delete**: `Messaging.canEdit` and `Messaging.canDelete` are bypassed for administrators.
+* **Visibility**: `Messaging.canViewMessage` is modified to always return `true` for admins.
+* **Room Locking**: `Messaging.canReply` is wrapped so non-admins cannot post in rooms locked by an admin.
+
+## Installation
+
+1. Install the plugin via terminal:
+   ```bash
+   npm install nodebb-plugin-admin-chats
+   ```
+2. Activate the plugin in the NodeBB Admin Control Panel (ACP).
+3. Restart NodeBB.
+
+## Client-Side Support
+The plugin includes a `client.js` script that:
+* Detects the system language (English or Hebrew).
+* Dynamically injects action buttons into the account sub-links menu.
+* Adds an admin lock/unlock control to the chat UI.
+* Disables the composer for non-admin users when a room is locked.
+* Cleans up the chat UI empty states for a better admin experience.
+
+---
+*Developed by [palmoni5](https://github.com/palmoni5/nodebb-plugin-admin-chats).*

package/client.js

@@ -1,5 +1,7 @@
 $(document).ready(function() {
-    
+    const LOCK_PREFIX = '[admin-chat-lock]';
+    const LOCKED_MESSAGE_TEXT = '🔒 חדר זה ננעל ע"י המנהלים.';
+
     function isEnglishSystem() {
         return $('html').attr('lang') && $('html').attr('lang').startsWith('en');
     }
@@ -9,33 +11,195 @@ $(document).ready(function() {
 
         $('span.text-muted.text-sm').each(function() {
             const currentText = $(this).text().trim();
-            
+
             if (currentText.includes("אין לכם צ'אטים פעילים") || currentText === "אין לכם צ'אטים פעילים.") {
                 $(this).text("אנא בחר צ'אט מסרגל הצד.");
                 $(this).removeClass('text-muted');
             }
 
-            if (currentText.includes("You have no active chats") || currentText === "You have no active chats.") {
-                $(this).text("Please select a chat from the sidebar.");
+            if (currentText.includes('You have no active chats') || currentText === 'You have no active chats.') {
+                $(this).text('Please select a chat from the sidebar.');
                 $(this).removeClass('text-muted');
             }
         });
     }
 
+    function getRoomData() {
+        if (!ajaxify || !ajaxify.data) {
+            return null;
+        }
+
+        return ajaxify.data.room || ajaxify.data;
+    }
+
+    function getLockText() {
+        if (isEnglishSystem()) {
+            return '🔒 This room was locked by the administrators.';
+        }
+
+        return LOCKED_MESSAGE_TEXT;
+    }
+
+    function renderLockBanner() {
+        const roomData = getRoomData();
+        const lockData = roomData && roomData.adminChatLock;
+        $('.admin-chat-lock-banner').remove();
+
+        if (!lockData || !lockData.isLocked) {
+            return;
+        }
+
+        const target = $('[component="chat/messages"]').first().parent();
+        if (!target.length) {
+            return;
+        }
+
+        target.prepend(`
+            <div class="admin-chat-lock-banner alert alert-warning mb-2">${getLockText()}</div>
+        `);
+    }
+
+    function setComposerVisibility(shouldHide) {
+        const selectors = [
+            '[component="chat/composer"]',
+            '[component="chat/replies"]',
+            '[component="chat/input"]',
+            '[component="chat/textarea"]',
+            '.chat-input',
+            '.composer',
+        ];
+
+        const seen = new Set();
+        selectors.forEach(function(selector) {
+            $(selector).each(function() {
+                const $element = $(this);
+                const $container = $element.closest('[component="chat/composer"], [component="chat/replies"], .chat-input, .composer').length ?
+                    $element.closest('[component="chat/composer"], [component="chat/replies"], .chat-input, .composer').first() :
+                    $element;
+                const domNode = $container.get(0);
+
+                if (!domNode || seen.has(domNode)) {
+                    return;
+                }
+
+                seen.add(domNode);
+                $container.toggle(!shouldHide);
+            });
+        });
+    }
+
+    function updateComposerState() {
+        const roomData = getRoomData();
+        const lockData = roomData && roomData.adminChatLock;
+        const shouldHideComposer = !!(lockData && lockData.isLocked && !(app.user && app.user.isAdmin));
+
+        $('[component="chat/input"], [component="chat/textarea"], textarea.chat-input, .chat-input textarea')
+            .prop('disabled', shouldHideComposer)
+            .attr('placeholder', shouldHideComposer ? getLockText() : null);
+
+        $('[component="chat/send"], .chat-send, button[component="chat/submit"]').prop('disabled', shouldHideComposer);
+
+        setComposerVisibility(shouldHideComposer);
+        renderLockBanner();
+    }
+
+    function normalizeLockMessages() {
+        $('[component="chat/message/content"], .chat-message-content').each(function() {
+            const $el = $(this);
+            const text = $el.text().trim();
+            if (!text.startsWith(LOCK_PREFIX)) {
+                return;
+            }
+
+            $el.text(text.replace(LOCK_PREFIX, '').trim());
+        });
+    }
+
+    function getRoomMenuTargets() {
+        return $('[component="chat/header"], .chat-header, [component="chat/nav"]')
+            .find('.dropdown-menu');
+    }
+
+    function renderAdminLockControl() {
+        $('.admin-chat-lock-toggle-item, .admin-chat-lock-divider').remove();
+
+        if (!app.user.isAdmin) {
+            return;
+        }
+
+        const roomData = getRoomData();
+        const roomId = roomData && roomData.roomId;
+        if (!roomId) {
+            return;
+        }
+
+        const menus = getRoomMenuTargets();
+        if (!menus.length) {
+            return;
+        }
+
+        const lockData = roomData.adminChatLock || {};
+        const isLocked = !!lockData.isLocked;
+        const itemText = isEnglishSystem() ? (isLocked ? 'Unlock Room' : 'Lock Room') : (isLocked ? 'פתח חדר' : 'נעל חדר');
+        const iconClass = isLocked ? 'fa-lock-open' : 'fa-lock';
+        const menuItemHtml = `
+            <li role="presentation" class="admin-chat-lock-item-wrap">
+                <a href="#" role="menuitem" class="dropdown-item rounded-1 d-flex align-items-center gap-2 admin-chat-lock-toggle-item" data-room-id="${roomId}" data-locked="${isLocked}">
+                    <i class="fa fa-fw ${iconClass}"></i>
+                    <span>${itemText}</span>
+                </a>
+            </li>
+            <li role="presentation" class="dropdown-divider admin-chat-lock-divider"></li>
+        `;
+
+        menus.each(function() {
+            const $menu = $(this);
+            if ($menu.find('.admin-chat-lock-toggle-item').length) {
+                return;
+            }
+
+            $menu.prepend(menuItemHtml);
+        });
+    }
+
+    async function toggleRoomLock(roomId, nextState) {
+        const response = await fetch(`${config.relative_path || ''}/api/admin-chats/${roomId}/lock`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-csrf-token': config.csrf_token,
+            },
+            body: JSON.stringify({ locked: nextState }),
+        });
+
+        if (!response.ok) {
+            throw new Error('Unable to update room lock');
+        }
+
+        return await response.json();
+    }
+
+    function refreshChatUi() {
+        replaceAdminEmptyStateText();
+        renderAdminLockControl();
+        updateComposerState();
+        normalizeLockMessages();
+    }
+
     $(window).on('action:ajaxify.end', function(ev, data) {
-        
-        if (app.user.isAdmin && ajaxify.data.template.name.startsWith('account/')) {
+        const templateName = ajaxify && ajaxify.data && ajaxify.data.template ? ajaxify.data.template.name : '';
+
+        if (app.user.isAdmin && templateName.startsWith('account/')) {
             const userSlug = ajaxify.data.userslug || (ajaxify.data.user && ajaxify.data.user.userslug);
-            
+
             if (userSlug) {
-                const buttonText = isEnglishSystem() ? "View Chats" : "צפיה בצ'אטים";
-                
-                const relativePath = config.relative_path || ''; 
+                const buttonText = isEnglishSystem() ? 'View Chats' : "צפיה בצ'אטים";
+                const relativePath = config.relative_path || '';
 
                 const btnHtml = `
                     <li role="presentation">
                         <a class="dropdown-item rounded-1 d-flex align-items-center gap-2" href="${relativePath}/user/${userSlug}/chats" role="menuitem">
-                            <i class="far fa-fw fa-comments"></i> 
+                            <i class="far fa-fw fa-comments"></i>
                             <span>${buttonText}</span>
                         </a>
                     </li>
@@ -49,14 +213,48 @@ $(document).ready(function() {
             }
         }
 
-        if (data.url.match(/^user\/.+\/chats/) || data.url === 'chats') {
-            replaceAdminEmptyStateText();
-            setTimeout(replaceAdminEmptyStateText, 500);
+        const url = data && data.url ? data.url : '';
+
+        if (url.match(/^user\/.+\/chats/) || url === 'chats') {
+            refreshChatUi();
+            setTimeout(refreshChatUi, 500);
         }
     });
 
-    $(window).on('action:chat.loaded', replaceAdminEmptyStateText);
+    $(window).on('action:chat.loaded', function() {
+        refreshChatUi();
+        setTimeout(refreshChatUi, 200);
+    });
+
     $(window).on('action:chat.closed', function() {
-        setTimeout(replaceAdminEmptyStateText, 200);
+        setTimeout(refreshChatUi, 200);
+    });
+
+    $(document).on('click', '.admin-chat-lock-toggle-item', async function(ev) {
+        ev.preventDefault();
+
+        const $button = $(this);
+        const roomId = parseInt($button.attr('data-room-id'), 10);
+        const isLocked = $button.attr('data-locked') === 'true';
+
+        if (!roomId) {
+            return;
+        }
+
+        $button.addClass('disabled').attr('aria-disabled', 'true');
+
+        try {
+            const result = await toggleRoomLock(roomId, !isLocked);
+            if (ajaxify && ajaxify.data) {
+                ajaxify.data.adminChatLock = result.lockData;
+                if (ajaxify.data.room) {
+                    ajaxify.data.room.adminChatLock = result.lockData;
+                }
+            }
+            ajaxify.refresh();
+        } catch (err) {
+            app.alertError(isEnglishSystem() ? 'Unable to update room lock.' : 'לא ניתן לעדכן את נעילת החדר.');
+            $button.removeClass('disabled').removeAttr('aria-disabled');
+        }
     });
-});
+});

package/library.js

@@ -3,20 +3,21 @@
 const User = require.main.require('./src/user');
 const Messaging = require.main.require('./src/messaging');
 const db = require.main.require('./src/database');
-const _ = require('lodash');
 
 const plugin = {};
+const LOCK_PREFIX = '[admin-chat-lock]';
+const LOCKED_MESSAGE_TEXT = '🔒 חדר זה ננעל ע"י המנהלים.';
+const UNLOCKED_MESSAGE_TEXT = '🔓 חדר זה נפתח מחדש ע"י המנהלים.';
 
 plugin.init = async function (params) {
-    
+    registerRoutes(params.router, params.middleware);
     overrideMessagingFunctions();
 };
 
-
 plugin.addProfileLink = async function (data) {
     try {
         const userSlug = data.user ? data.user.userslug : (data.userData ? data.userData.userslug : null);
-        
+
         if (userSlug) {
             data.links.push({
                 id: 'admin-view-chats',
@@ -55,10 +56,19 @@ plugin.isUserInRoom = async function (payload) {
 };
 
 plugin.canReply = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.uid);
+    const uid = getCallerUid(payload);
+    const roomId = getRoomId(payload);
+    const isAdmin = await User.isAdministrator(uid);
+
     if (isAdmin) {
         payload.canReply = true;
+        return payload;
     }
+
+    if (roomId && await isRoomLocked(roomId)) {
+        payload.canReply = false;
+    }
+
     return payload;
 };
 
@@ -88,36 +98,56 @@ plugin.canGetPublicChats = async function (payload) {
 
 plugin.onLoadRoom = async function (payload) {
     const { uid, room } = payload;
+    if (!room) {
+        return payload;
+    }
+
     const isAdmin = await User.isAdministrator(uid);
+    const lockData = await getRoomLockData(room.roomId);
+    room.adminChatLock = lockData;
 
-    if (!isAdmin || !room) return payload;
+    if (lockData.isLocked) {
+        room.messages = appendLockNotice(room.messages, lockData);
+    }
+
+    if (!isAdmin) {
+        return payload;
+    }
 
     const isOfficialMember = await db.isSortedSetMember(`chat:room:${room.roomId}:uids`, uid);
 
     if (!isOfficialMember) {
         await db.sortedSetRemove(`chat:room:${room.roomId}:uids:online`, uid);
-        
+
         if (Array.isArray(room.users)) {
             room.users = room.users.filter(user => user && parseInt(user.uid, 10) !== parseInt(uid, 10));
         }
-
         if (room.userCount > 0) {
             room.userCount -= 1;
         }
         room.groupChat = room.userCount > 2;
 
         const allMids = await db.getSortedSetRevRange(`chat:room:${room.roomId}:mids`, 0, 49);
-        
+
         if (allMids.length > 0) {
             const messages = await Messaging.getMessagesData(allMids, uid, room.roomId, false);
             const messageCount = await db.getObjectField(`chat:room:${room.roomId}`, 'messageCount');
             const count = parseInt(messageCount, 10) || 0;
-            
+
             messages.forEach((msg, index) => {
                 msg.index = count - index - 1;
             });
-            
-            room.messages = messages.reverse();
+
+            room.messages = appendLockNotice(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);
+                }
+            });
         }
 
         room.isAdmin = true;
@@ -125,15 +155,14 @@ plugin.onLoadRoom = async function (payload) {
     } else {
         room.isAdmin = true;
     }
-
     return payload;
 };
 
 function overrideMessagingFunctions() {
-    
     const originalCanEdit = Messaging.canEdit;
     const originalCanDelete = Messaging.canDelete;
     const originalCanViewMessage = Messaging.canViewMessage;
+    const originalCanReply = Messaging.canReply;
 
     Messaging.canEdit = async function (messageId, uid) {
         if (await User.isAdministrator(uid)) {
@@ -155,6 +184,189 @@ function overrideMessagingFunctions() {
         }
         return await originalCanViewMessage(mids, roomId, uid);
     };
+
+    if (typeof originalCanReply === 'function') {
+        Messaging.canReply = async function (...args) {
+            const guessed = guessRoomIdUidFromArgs(args);
+            if (await User.isAdministrator(guessed.uid)) {
+                return true;
+            }
+            if (guessed.roomId && await isRoomLocked(guessed.roomId)) {
+                return false;
+            }
+            return await originalCanReply.apply(this, args);
+        };
+    }
+};
+
+function registerRoutes(router, middleware) {
+    if (!router) {
+        return;
+    }
+
+    const routeMiddleware = [];
+    if (middleware && typeof middleware.ensureLoggedIn === 'function') {
+        routeMiddleware.push(middleware.ensureLoggedIn);
+    }
+
+    router.post('/api/admin-chats/:roomId/lock', ...routeMiddleware, async (req, res) => {
+        try {
+            const actingUid = req.uid;
+            const roomId = parseInt(req.params.roomId, 10);
+
+            if (!actingUid || Number.isNaN(roomId)) {
+                return res.status(400).json({ status: { code: 'bad-request', message: 'Invalid room id' } });
+            }
+
+            if (!await User.isAdministrator(actingUid)) {
+                return res.status(403).json({ status: { code: 'forbidden', message: 'Admin only' } });
+            }
+
+            if (!await roomExists(roomId)) {
+                return res.status(404).json({ status: { code: 'not-found', message: 'Room not found' } });
+            }
+
+            const shouldLock = req.body && typeof req.body.locked === 'boolean' ? req.body.locked : true;
+            const lockData = shouldLock ?
+                await lockRoom(roomId, actingUid) :
+                await unlockRoom(roomId, actingUid);
+
+            return res.json({
+                status: { code: 'ok', message: 'Room updated' },
+                roomId,
+                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 roomExists(roomId) {
+    const roomData = await db.getObject(`chat:room:${roomId}`);
+    return !!roomData;
+}
+
+async function lockRoom(roomId, actingUid) {
+    const now = Date.now();
+    await db.setObject(`chat:room:${roomId}:adminLock`, {
+        isLocked: 1,
+        lockedBy: actingUid,
+        lockedAt: now,
+    });
+
+    await addLockSystemMessage(roomId, actingUid, true);
+    return await getRoomLockData(roomId);
+}
+
+async function unlockRoom(roomId, actingUid) {
+    await db.setObject(`chat:room:${roomId}:adminLock`, {
+        isLocked: 0,
+        lockedBy: 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 getRoomLockData(roomId) {
+    const data = await db.getObject(`chat:room:${roomId}:adminLock`) || {};
+    const lockedBy = parseInt(data.lockedBy, 10) || 0;
+    const lockedAt = parseInt(data.lockedAt, 10) || 0;
+    const isLockedValue = data.isLocked === '1' || data.isLocked === 1 || data.isLocked === true;
+
+    return {
+        isLocked: isLockedValue,
+        lockedBy,
+        lockedAt,
+    };
+}
+
+function appendLockNotice(messages, lockData) {
+    const list = Array.isArray(messages) ? messages.slice() : [];
+    if (!lockData || !lockData.isLocked || !lockData.lockedAt) {
+        return list;
+    }
+
+    const content = `${LOCK_PREFIX} ${LOCKED_MESSAGE_TEXT}`;
+    const exists = list.some(msg => msg && msg.content === content);
+    if (exists) {
+        return list;
+    }
+
+    list.push({
+        content,
+        fromuid: lockData.lockedBy,
+        uid: lockData.lockedBy,
+        timestamp: lockData.lockedAt,
+        datetime: lockData.lockedAt,
+        system: true,
+        newSet: true,
+    });
+
+    list.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;
+}
+
+function guessRoomIdUidFromArgs(args) {
+    if (!Array.isArray(args) || !args.length) {
+        return { roomId: null, uid: null };
+    }
+
+    if (args.length === 1 && args[0] && typeof args[0] === 'object') {
+        return {
+            roomId: getRoomId(args[0]),
+            uid: getCallerUid(args[0]),
+        };
+    }
+
+    return {
+        roomId: args[0],
+        uid: args[1],
+    };
+}
+
+function getCallerUid(payload) {
+    return payload && (
+        payload.uid ||
+        payload.callerUid ||
+        (payload.data && payload.data.uid) ||
+        (payload.message && payload.message.uid)
+    );
+}
+
+function getRoomId(payload) {
+    return payload && (
+        payload.roomId ||
+        (payload.data && payload.data.roomId) ||
+        (payload.message && payload.message.roomId)
+    );
 }
 
 module.exports = plugin;

package/package.json

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