nodebb-plugin-admin-chats 2.1.0 → 3.0.0

package/README.md

@@ -4,8 +4,8 @@ A professional administration plugin for NodeBB that allows administrators to mo
 
 ## 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.
+* **Global Chat Access**: Administrators and users with chat view permission can view any private or group conversation.
+* **Management Privileges**: Administrators and users with chat management permission can 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.
@@ -16,7 +16,17 @@ A professional administration plugin for NodeBB that allows administrators to mo
 ### Plugin Information
 * **Name**: Super Admin Chat Control
 * **ID**: `nodebb-plugin-admin-chats`
-* **Compatibility**: NodeBB versions `^3.0.0` or `^4.0.0`
+* **Compatibility**: NodeBB version `^4.0.0`
+
+### Permissions
+The plugin exposes two global permissions in the ACP:
+
+* `admin-chats:view`: View any chat room and load history (read-only access).
+* `admin-chats:manage`: Manage any chat room (edit/delete messages, lock/unlock rooms, and other moderator-level actions).
+
+### Chat Route Behavior (`/chats`)
+NodeBB exposes a core route at `/chats` (and `/chats/:roomId/:index?`) that redirects logged-in users to their personal chat page under `/user/:userslug/chats/...`.
+This plugin also rewrites chat notification links to use `/user/:userslug/chats/...`, ensuring admins land on the correct user-scoped chat view when opening notifications.
 
 ### Implemented Hooks
 The plugin utilizes several filters to elevate administrator permissions:
@@ -37,6 +47,14 @@ The plugin overrides core messaging functions to ensure full administrative cont
 
 ## Installation
 
+### Option 1: Via Admin Control Panel (Recommended)
+1. Navigate to the NodeBB Admin Control Panel (ACP).
+2. Go to **Extend** → **Plugins**.
+3. Search for "nodebb-plugin-admin-chats".
+4. Click **Install**.
+5. Activate the plugin and restart NodeBB.
+
+### Option 2: Via Terminal
 1. Install the plugin via terminal:
    ```bash
    npm install nodebb-plugin-admin-chats
@@ -53,4 +71,4 @@ The plugin includes a `client.js` script that:
 * Cleans up the chat UI empty states for a better admin experience.
 
 ---
-*Developed by [palmoni5](https://github.com/palmoni5/nodebb-plugin-admin-chats).*
+*Developed by [palmoni5](https://github.com/palmoni5/nodebb-plugin-admin-chats).* 

package/client.js

@@ -1,4 +1,6 @@
 $(document).ready(function() {
+    syncAdminAccessFromAjaxify();
+    fetchAdminPrivileges();
     const LOCK_PREFIX = '[admin-chat-lock]';
     const roomStateCache = new Map();
     const TEXT = {
@@ -25,12 +27,106 @@ $(document).ready(function() {
     function isEnglishSystem() {
         return $('html').attr('lang') && $('html').attr('lang').startsWith('en');
     }
-
     function t(key) {
         const dict = isEnglishSystem() ? TEXT.en : TEXT.he;
         return dict[key];
     }
 
+    function hasAdminChatsAccess() {
+        return !!((ajaxify && ajaxify.data && (ajaxify.data.adminChatsAccess || ajaxify.data.adminChatsCanManage)) || window.adminChatsAccess || window.adminChatsCanManage || (app.user && app.user.isAdmin));
+    }
+
+    function isAdminUser() {
+        return !!((ajaxify && ajaxify.data && ajaxify.data.adminChatsIsAdmin) || window.adminChatsIsAdmin || (app.user && app.user.isAdmin));
+    }
+
+    async function fetchAdminPrivileges() {
+        if (!hasAdminChatsAccess() || window.adminChatsPrivilegesPending) {
+            return;
+        }
+
+        window.adminChatsPrivilegesPending = true;
+        try {
+            const response = await fetch(`${config.relative_path || ''}/api/admin-chats/privileges`, {
+                headers: {
+                    'x-csrf-token': config.csrf_token,
+                },
+                credentials: 'same-origin',
+            });
+
+            if (!response.ok) {
+                return;
+            }
+
+            const payload = await response.json();
+            if (payload && typeof payload.adminChatsAccess === 'boolean') {
+                window.adminChatsAccess = payload.adminChatsAccess;
+            }
+            if (payload && typeof payload.adminChatsCanManage === 'boolean') {
+                window.adminChatsCanManage = payload.adminChatsCanManage;
+            }
+            if (payload && typeof payload.adminChatsIsAdmin === 'boolean') {
+                window.adminChatsIsAdmin = payload.adminChatsIsAdmin;
+            }
+        } catch (err) {
+            // ignore
+        } finally {
+            window.adminChatsPrivilegesPending = false;
+        }
+    }
+
+    function syncAdminAccessFromAjaxify() {
+        if (!ajaxify || !ajaxify.data) {
+            return;
+        }
+        if (typeof ajaxify.data.adminChatsAccess === 'boolean') {
+            window.adminChatsAccess = ajaxify.data.adminChatsAccess;
+        }
+        if (typeof ajaxify.data.adminChatsCanManage === 'boolean') {
+            window.adminChatsCanManage = ajaxify.data.adminChatsCanManage;
+        }
+        if (typeof ajaxify.data.adminChatsIsAdmin === 'boolean') {
+            window.adminChatsIsAdmin = ajaxify.data.adminChatsIsAdmin;
+        }
+    }
+
+    function canManageChats() {
+        return !!((ajaxify && ajaxify.data && ajaxify.data.adminChatsCanManage) || window.adminChatsCanManage || isAdminUser());
+    }
+
+    let adminChatsAccessProbe = null;
+
+    function resolveAdminChatsAccess() {
+        if (hasAdminChatsAccess()) {
+            return Promise.resolve(true);
+        }
+        if (window.adminChatsAccessChecked) {
+            return Promise.resolve(false);
+        }
+        if (adminChatsAccessProbe) {
+            return adminChatsAccessProbe;
+        }
+
+        adminChatsAccessProbe = fetch(`${config.relative_path || ''}/api/admin-chats?start=0`, {
+            headers: {
+                'x-csrf-token': config.csrf_token,
+            },
+            credentials: 'same-origin',
+        }).then((response) => {
+            const ok = response && response.ok;
+            window.adminChatsAccess = ok;
+            return ok;
+        }).catch(() => {
+            window.adminChatsAccess = false;
+            return false;
+        }).finally(() => {
+            window.adminChatsAccessChecked = true;
+            adminChatsAccessProbe = null;
+        });
+
+        return adminChatsAccessProbe;
+    }
+
     // Get lockedAction message from server translations only (based on forum settings)
     function getLockedActionMessage() {
         if (window.adminChatsTranslations && window.adminChatsTranslations.lockedAction) {
@@ -160,12 +256,20 @@ $(document).ready(function() {
                 Chats._adminAllChatsPatched = true;
             }
 
+            // Auto-open chat if roomId is specified in URL
+            const currentRoomId = ajaxify && ajaxify.data && ajaxify.data.roomId;
+            if (currentRoomId && !$('body').hasClass('chat-loaded')) {
+                setTimeout(function() {
+                    Chats.switchChat(currentRoomId);
+                }, 100);
+            }
+
             bindAdminRecentChatsInfiniteScroll();
         });
     }
 
     function replaceAdminEmptyStateText() {
-        if (!app.user.isAdmin) {
+        if (!hasAdminChatsAccess()) {
             return;
         }
 
@@ -239,19 +343,50 @@ $(document).ready(function() {
             credentials: 'same-origin',
         });
         if (!response.ok) {
+            if (hasAdminChatsAccess() && !isAdminAllChatsPage()) {
+                const adminResponse = await fetch(`${config.relative_path || ''}/api/admin-chats/page/${roomId}`, {
+                    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);
+                }
+                return adminRoom;
+            }
             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}`, {
+                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 (roomData) {
             setCachedRoomData(roomId, roomData);
         }
         return roomData;
     }
-
     function isLockedForUser(roomData) {
-        return !!(roomData && roomData.adminChatLock && roomData.adminChatLock.isLocked && !(app.user && app.user.isAdmin));
+        return !!(roomData && roomData.adminChatLock && roomData.adminChatLock.isLocked && !canManageChats());
     }
 
     function setComposerHidden($window, hidden) {
@@ -306,6 +441,15 @@ $(document).ready(function() {
             .toggleClass('hidden', hidden);
     }
 
+    function updateDeleteRestoreVisibility($window) {
+        $window.find('[component="chat/message"]').each(function() {
+            const $message = $(this);
+            const isDeleted = $message.hasClass('deleted');
+            $message.find('[data-action="delete"]').toggleClass('hidden', isDeleted).toggle(!isDeleted);
+            $message.find('[data-action="restore"]').toggleClass('hidden', !isDeleted).toggle(isDeleted);
+        });
+    }
+
     function normalizeLockMessages($window) {
         $window.find('[component="chat/system-message"] > div').each(function() {
             const $el = $(this);
@@ -328,7 +472,7 @@ $(document).ready(function() {
     function renderAdminLockControl($window, roomData) {
         $window.find('.admin-chat-lock-toggle-item, .admin-chat-lock-divider, .admin-chat-lock-item-wrap').remove();
 
-        if (!app.user.isAdmin || !roomData || !roomData.roomId) {
+        if (!canManageChats() || !roomData || !roomData.roomId) {
             return;
         }
 
@@ -374,6 +518,7 @@ $(document).ready(function() {
         const hidden = isLockedForUser(roomData);
         setComposerHidden($window, hidden);
         updateLockedActionVisibility($window, hidden);
+        updateDeleteRestoreVisibility($window);
         renderLockBanner($window, hidden);
         renderAdminLockControl($window, roomData);
         normalizeLockMessages($window);
@@ -444,33 +589,30 @@ $(document).ready(function() {
     }
 
     $(window).on('action:ajaxify.end', function(ev, data) {
+        syncAdminAccessFromAjaxify();
+        fetchAdminPrivileges();
         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 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>
-                            <span>${t('viewChats')}</span>
-                        </a>
-                    </li>
-                    <li role="presentation" class="dropdown-divider"></li>
-                `;
-                const menu = $('.account-sub-links');
-                if (menu.length) {
-                    menu.find(`a[href*="/user/${userSlug}/chats"]`).parent().remove();
-                    menu.prepend(btnHtml);
-                }
-            }
+        if (templateName.startsWith('account/')) {
+            injectProfileChatsMenu();
+            setTimeout(injectProfileChatsMenu, 200);
         }
 
         if (isAdminAllChatsPage()) {
             patchForumChatsForAdminAll();
             bindAdminRecentChatsInfiniteScroll();
+            
+            // Auto-open chat if roomId is specified in URL and chat is not already loaded
+            const currentRoomId = ajaxify && ajaxify.data && ajaxify.data.roomId;
+            if (currentRoomId && !$('body').hasClass('chat-loaded')) {
+                setTimeout(function() {
+                    require(['forum/chats'], function(Chats) {
+                        if (Chats && Chats.switchChat) {
+                            Chats.switchChat(currentRoomId);
+                        }
+                    });
+                }, 200);
+            }
         }
 
         const url = data && data.url ? data.url : '';
@@ -478,6 +620,11 @@ $(document).ready(function() {
             refreshChatUi();
             setTimeout(refreshChatUi, 500);
             setTimeout(refreshChatUi, 1200);
+            
+            // Handle chat navigation for internal URL changes
+            if (url.match(/^chats\/\d+/)) {
+                setTimeout(handleChatNavigation, 300);
+            }
         }
     });
 
@@ -485,6 +632,20 @@ $(document).ready(function() {
         if (isAdminAllChatsPage()) {
             patchForumChatsForAdminAll();
             bindAdminRecentChatsInfiniteScroll();
+            
+            // Auto-open chat if roomId is specified in URL and no chat is currently active
+            const currentRoomId = ajaxify && ajaxify.data && ajaxify.data.roomId;
+            const activeChatId = $('[component="chat/main-wrapper"]').attr('data-roomid');
+            
+            if (currentRoomId && (!activeChatId || activeChatId !== String(currentRoomId))) {
+                setTimeout(function() {
+                    require(['forum/chats'], function(Chats) {
+                        if (Chats && Chats.switchChat) {
+                            Chats.switchChat(currentRoomId);
+                        }
+                    });
+                }, 100);
+            }
         }
         refreshChatUi();
         setTimeout(refreshChatUi, 200);
@@ -499,6 +660,58 @@ $(document).ready(function() {
         setTimeout(refreshChatUi, 0);
     });
 
+    if (window.socket) {
+        socket.removeListener('event:chats.delete', refreshChatUi);
+        socket.removeListener('event:chats.restore', refreshChatUi);
+        socket.on('event:chats.delete', function() { setTimeout(refreshChatUi, 0); });
+        socket.on('event:chats.restore', function() { setTimeout(refreshChatUi, 0); });
+    }
+
+    // Handle browser back/forward navigation
+    $(window).on('popstate', function() {
+        if (isAdminAllChatsPage()) {
+            setTimeout(handleChatNavigation, 100);
+        }
+    });
+
+    // Handle URL changes for internal navigation
+    function handleChatNavigation() {
+        if (!isAdminAllChatsPage()) {
+            return;
+        }
+        
+        // Try to get roomId from multiple sources
+        let currentRoomId = ajaxify && ajaxify.data && ajaxify.data.roomId;
+        
+        // If not found in ajaxify.data, try to extract from URL
+        if (!currentRoomId) {
+            const urlMatch = window.location.pathname.match(/\/chats\/(\d+)/);
+            if (urlMatch) {
+                currentRoomId = parseInt(urlMatch[1], 10);
+            }
+        }
+        
+        const activeChatId = $('[component="chat/main-wrapper"]').attr('data-roomid');
+        
+        if (currentRoomId && (!activeChatId || activeChatId !== String(currentRoomId))) {
+            require(['forum/chats'], function(Chats) {
+                if (Chats && Chats.switchChat) {
+                    Chats.switchChat(currentRoomId);
+                }
+            });
+        }
+    }
+
+    $(document).on('click', '[data-action="delete"], [data-action="restore"]', function() {
+        const $window = $(this).closest('[component="chat/message/window"]');
+        if (!$window.length) {
+            return;
+        }
+        setTimeout(function() {
+            updateDeleteRestoreVisibility($window);
+        }, 50);
+    });
+
     $(document).on('click', '.admin-chat-lock-toggle-item', async function(ev) {
         ev.preventDefault();
 
@@ -517,7 +730,7 @@ $(document).ready(function() {
             const currentRoom = ajaxify && ajaxify.data && (ajaxify.data.room || ajaxify.data);
             if (currentRoom && parseInt(currentRoom.roomId, 10) === roomId) {
                 currentRoom.adminChatLock = result.lockData;
-                currentRoom.canReply = !result.lockData.isLocked || (app.user && app.user.isAdmin);
+                currentRoom.canReply = !result.lockData.isLocked || canManageChats();
                 currentRoom.showUserInput = currentRoom.canReply;
                 if (ajaxify.data.room) {
                     ajaxify.data.room.adminChatLock = result.lockData;
@@ -528,7 +741,7 @@ $(document).ready(function() {
 
             const cached = getCachedRoomData(roomId) || { roomId };
             cached.adminChatLock = result.lockData;
-            cached.canReply = !result.lockData.isLocked || (app.user && app.user.isAdmin);
+            cached.canReply = !result.lockData.isLocked || canManageChats();
             cached.showUserInput = cached.canReply;
             setCachedRoomData(roomId, cached);
             await refreshChatUi();
@@ -552,4 +765,3 @@ $(document).ready(function() {
         app.alertError._adminChatsWrapped = true;
     }
 });
-

package/library.js

@@ -11,6 +11,8 @@ const helpers = require.main.require('./src/controllers/helpers');
 const plugin = {};
 const LOCK_PREFIX = '[admin-chat-lock]';
 const LOCKED_MESSAGE_TEXT = '🔒 חדר זה ננעל ע"י המנהלים.';
+const ADMIN_CHATS_PRIVILEGE = 'admin-chats:view';
+const ADMIN_CHATS_MANAGE_PRIVILEGE = 'admin-chats:manage';
 
 async function getLockedActionMessage(uid) {
     try {
@@ -36,13 +38,121 @@ async function getLockedActionMessage(uid) {
 const ADMIN_CHAT_PAGE_SIZE = 30;
 const ADMIN_CHAT_SCAN_SIZE = 100;
 
+async function canAccessAdminChats(uid) {
+    if (!uid) {
+        return false;
+    }
+
+    const [isAdmin, canView, canManage] = await Promise.all([
+        User.isAdministrator(uid),
+        privileges.global.can(ADMIN_CHATS_PRIVILEGE, uid),
+        privileges.global.can(ADMIN_CHATS_MANAGE_PRIVILEGE, uid),
+    ]);
+
+    return isAdmin || canView || canManage;
+}
+
+async function canManageAdminChats(uid) {
+    if (!uid) {
+        return false;
+    }
+
+    const [isAdmin, canManage] = await Promise.all([
+        User.isAdministrator(uid),
+        privileges.global.can(ADMIN_CHATS_MANAGE_PRIVILEGE, uid),
+    ]);
+
+    return isAdmin || canManage;
+}
+
+async function isUserMemberOfRoom(uid, roomId) {
+    if (!uid || !roomId) {
+        return false;
+    }
+
+    return await db.isSortedSetMember(`chat:room:${roomId}:uids`, uid);
+}
 plugin.init = async function (params) {
     registerRoutes(params.app, params.router, params.middleware);
     overrideMessagingFunctions();
     overrideChatsApi();
     overrideCoreChatRedirect(params.controllers);
 };
+plugin.registerPrivileges = async function (data) {
+    if (!data || !data.privileges || typeof data.privileges.set !== 'function') {
+        return data;
+    }
+
+    data.privileges.set(ADMIN_CHATS_PRIVILEGE, {
+        label: '[[admin-chats:admin-chats-view]]',
+        type: 'moderation',
+    });
+
+    data.privileges.set(ADMIN_CHATS_MANAGE_PRIVILEGE, {
+        label: '[[admin-chats:admin-chats-manage]]',
+        type: 'moderation',
+    });
+
+    return data;
+};
 
+plugin.filterNotificationCreate = async function (data) {
+    if (!data || !data.data) {
+        return data;
+    }
+
+    const notification = data.data;
+    
+    // Check if this is a chat notification with path like /chats/123
+    if (notification.path && notification.path.match(/^\/chats\/\d+/)) {
+        const chatMatch = notification.path.match(/^\/chats\/(\d+)(?:\/(\d+))?$/);
+        if (chatMatch && notification && notification.uid) {
+            const roomId = chatMatch[1];
+            const index = chatMatch[2];
+            
+            // Get the user's slug to redirect to their personal chat page
+            const userSlug = await User.getUserField(notification.uid, 'userslug');
+            if (userSlug) {
+                notification.path = `/user/${userSlug}/chats/${roomId}${index ? `/${index}` : ''}`;
+            }
+        }
+    }
+
+    return data;
+};
+
+plugin.filterUserNotificationsGetNotifications = async function (data) {
+    if (!data || !data.uid || !Array.isArray(data.notifications) || !data.notifications.length) {
+        return data;
+    }
+
+    const userSlug = await User.getUserField(data.uid, 'userslug');
+    if (!userSlug) {
+        return data;
+    }
+
+    const userPathRegex = /\/user\/[^/]+\/chats\//;
+    const chatPathRegex = /\/chats\/(\d+)(?:\/(\d+))?(?=$|[/?#])/;
+
+    data.notifications.forEach((notification) => {
+        if (!notification || !notification.path) {
+            return;
+        }
+        if (userPathRegex.test(notification.path)) {
+            return;
+        }
+        const match = notification.path.match(chatPathRegex);
+        if (!match) {
+            return;
+        }
+        const roomId = match[1];
+        const index = match[2];
+        const replacement = `/user/${userSlug}/chats/${roomId}${index ? `/${index}` : ''}`;
+        notification.path = notification.path.replace(chatPathRegex, replacement);
+    });
+
+    return data;
+};
 plugin.addScripts = async function (data) {
     let isHebrew = false;
     
@@ -70,10 +180,14 @@ plugin.addScripts = async function (data) {
         lockedAction: isHebrew ? 'לא ניתן לבצע פעולה זו בחדר נעול' : 'This action cannot be performed in a locked room.',
     };
 
+    const isAdmin = uid ? await User.isAdministrator(uid) : false;
+    const adminChatsManage = uid ? (isAdmin || await privileges.global.can(ADMIN_CHATS_MANAGE_PRIVILEGE, uid)) : false;
+    const adminChatsAccess = uid ? (isAdmin || adminChatsManage || await privileges.global.can(ADMIN_CHATS_PRIVILEGE, uid)) : false;
+
     data.scripts = data.scripts || [];
     data.scripts.push({
         src: false,
-        script: `window.adminChatsTranslations = ${JSON.stringify(translations)};`
+        script: `window.adminChatsTranslations = ${JSON.stringify(translations)}; window.adminChatsAccess = ${adminChatsAccess}; window.adminChatsIsAdmin = ${isAdmin}; window.adminChatsCanManage = ${adminChatsManage};`
     });
 
     return data;
@@ -81,6 +195,11 @@ plugin.addScripts = async function (data) {
 
 plugin.addProfileLink = async function (data) {
     try {
+        const uid = data && (data.uid || (data.req && data.req.uid));
+        if (!uid || !await canAccessAdminChats(uid)) {
+            return data;
+        }
+
         const userSlug = data.user ? data.user.userslug : (data.userData ? data.userData.userslug : null);
 
         if (userSlug) {
@@ -88,12 +207,12 @@ plugin.addProfileLink = async function (data) {
                 id: 'admin-view-chats',
                 route: 'user/' + userSlug + '/chats',
                 icon: 'fa-comments',
-                name: 'צפה בצ\'אטים',
+                name: '[[admin-chats:profile.viewChats]]',
                 visibility: {
-                    self: false,
+                    self: true,
                     other: true,
-                    moderator: false,
-                    globalMod: false,
+                    moderator: true,
+                    globalMod: true,
                     admin: true,
                 }
             });
@@ -105,16 +224,19 @@ plugin.addProfileLink = async function (data) {
 };
 
 plugin.isRoomOwner = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.uid);
-    if (isAdmin) {
+    const [isAdmin, canManage] = await Promise.all([
+        User.isAdministrator(payload.uid),
+        canManageAdminChats(payload.uid),
+    ]);
+    if (isAdmin || canManage) {
         payload.isOwner = true;
     }
     return payload;
 };
 
 plugin.isUserInRoom = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.uid);
-    if (isAdmin) {
+    const uid = getCallerUid(payload);
+    if (await canAccessAdminChats(uid)) {
         payload.inRoom = true;
     }
     return payload;
@@ -123,13 +245,28 @@ plugin.isUserInRoom = async function (payload) {
 plugin.canReply = async function (payload) {
     const uid = getCallerUid(payload);
     const roomId = getRoomId(payload);
-    const isAdmin = await User.isAdministrator(uid);
 
-    if (isAdmin) {
+    const [isAdmin, canView, canManage] = await Promise.all([
+        User.isAdministrator(uid),
+        privileges.global.can(ADMIN_CHATS_PRIVILEGE, uid),
+        privileges.global.can(ADMIN_CHATS_MANAGE_PRIVILEGE, uid),
+    ]);
+    const isManager = isAdmin || canManage;
+    const hasAccess = isAdmin || canView || canManage;
+
+    if (isManager) {
         payload.canReply = true;
         return payload;
     }
 
+    if (roomId && hasAccess) {
+        const isMember = await isUserMemberOfRoom(uid, roomId);
+        if (!isMember) {
+            payload.canReply = false;
+            return payload;
+        }
+    }
+
     if (roomId && await isRoomLocked(roomId)) {
         payload.canReply = false;
     }
@@ -149,6 +286,17 @@ plugin.filterMessagingSend = async function (payload) {
         return payload;
     }
 
+    if (await canManageAdminChats(uid)) {
+        return payload;
+    }
+
+    if (await canAccessAdminChats(uid)) {
+        const isMember = await isUserMemberOfRoom(uid, roomId);
+        if (!isMember) {
+            throw new Error('[[error:no-privileges]]');
+        }
+    }
+
     if (await isRoomLocked(roomId)) {
         const message = await getLockedActionMessage(uid);
         throw new Error(message);
@@ -157,6 +305,9 @@ plugin.filterMessagingSend = async function (payload) {
     return payload;
 };
 plugin.filterAddUsersToRoom = async function (payload) {
+    if (await canManageAdminChats(payload.uid)) {
+        return payload;
+    }
     if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
         const message = await getLockedActionMessage(payload.uid);
         throw new Error(message);
@@ -165,6 +316,9 @@ plugin.filterAddUsersToRoom = async function (payload) {
 };
 
 plugin.filterRemoveUsersFromRoom = async function (payload) {
+    if (await canManageAdminChats(payload.uid)) {
+        return payload;
+    }
     if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
         const message = await getLockedActionMessage(payload.uid);
         throw new Error(message);
@@ -173,6 +327,9 @@ plugin.filterRemoveUsersFromRoom = async function (payload) {
 };
 
 plugin.filterRenameRoom = async function (payload) {
+    if (await canManageAdminChats(payload.uid)) {
+        return payload;
+    }
     if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
         const message = await getLockedActionMessage(payload.uid);
         throw new Error(message);
@@ -181,24 +338,21 @@ plugin.filterRenameRoom = async function (payload) {
 };
 
 plugin.canGetMessages = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.callerUid);
-    if (isAdmin) {
+    if (await canAccessAdminChats(payload.callerUid)) {
         payload.canGet = true;
     }
     return payload;
 };
 
 plugin.canGetRecentChats = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.callerUid);
-    if (isAdmin) {
+    if (await canAccessAdminChats(payload.callerUid)) {
         payload.canGet = true;
     }
     return payload;
 };
 
 plugin.canGetPublicChats = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.callerUid);
-    if (isAdmin) {
+    if (await canAccessAdminChats(payload.callerUid)) {
         payload.canGet = true;
     }
     return payload;
@@ -210,20 +364,27 @@ plugin.onLoadRoom = async function (payload) {
         return payload;
     }
 
-    const isAdmin = await User.isAdministrator(uid);
+    const [isAdmin, canView, canManage] = await Promise.all([
+        User.isAdministrator(uid),
+        privileges.global.can(ADMIN_CHATS_PRIVILEGE, uid),
+        privileges.global.can(ADMIN_CHATS_MANAGE_PRIVILEGE, uid),
+    ]);
+    const isManager = isAdmin || canManage;
+    const hasAccess = isAdmin || canView || canManage;
+
     const lockData = await getRoomLockData(room.roomId);
-    const isLockedForUser = lockData.isLocked && !isAdmin;
+    const isLockedForUser = lockData.isLocked && !isManager;
 
     room.adminChatLock = lockData;
     room.messages = ensureFirstVisibleMessageHeader(buildRoomMessagesWithLockNotice(room.messages, lockData));
     room.canReply = room.canReply && !isLockedForUser;
     room.showUserInput = room.showUserInput && !isLockedForUser;
 
-    if (!isAdmin) {
+    if (!hasAccess) {
         return payload;
     }
 
-    const isOfficialMember = await db.isSortedSetMember(`chat:room:${room.roomId}:uids`, uid);
+    const isOfficialMember = await isUserMemberOfRoom(uid, room.roomId);
 
     if (!isOfficialMember) {
         await db.sortedSetRemove(`chat:room:${room.roomId}:uids:online`, uid);
@@ -268,12 +429,24 @@ plugin.onLoadRoom = async function (payload) {
 
             room.messages = ensureFirstVisibleMessageHeader(room.messages);
         }
+    }
+
+    if (!isManager && !isOfficialMember) {
+        room.canReply = false;
+        room.showUserInput = false;
+    }
 
-        room.isAdmin = true;
+    room.isAdmin = isManager;
+    room.isAdminOrGlobalMod = isManager;
+    payload.isAdminOrGlobalMod = isManager;
+    if (isManager) {
         room.isOwner = true;
-    } else {
-        room.isAdmin = true;
     }
+    room.adminChatsAccess = hasAccess;
+    payload.adminChatsAccess = hasAccess;
+    payload.adminChatsCanManage = isManager;
+    payload.adminChatsIsAdmin = isAdmin;
+
     return payload;
 };
 
@@ -285,7 +458,7 @@ function overrideCoreChatRedirect(controllers) {
 
     const originalRedirectToChat = chatsController.redirectToChat;
     const wrappedRedirectToChat = async function (req, res, next) {
-        if (req && req.uid && await User.isAdministrator(req.uid)) {
+        if (req && req.uid && await canAccessAdminChats(req.uid)) {
             return await renderAdminChatsPage(req, res, next);
         }
 
@@ -303,7 +476,7 @@ function overrideChatsApi() {
 
     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)) {
+        if (caller && !await User.isAdministrator(caller.uid) && !await canManageAdminChats(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);
         }
@@ -325,6 +498,10 @@ function overrideMessagingFunctions() {
             return true;
         }
 
+        if (await canManageAdminChats(uid)) {
+            return true;
+        }
+
         const roomId = await getMessageRoomId(messageId);
         if (roomId && await isRoomLocked(roomId)) {
             const message = await getLockedActionMessage(uid);
@@ -339,6 +516,10 @@ function overrideMessagingFunctions() {
             return true;
         }
 
+        if (await canManageAdminChats(uid)) {
+            return true;
+        }
+
         const roomId = await getMessageRoomId(messageId);
         if (roomId && await isRoomLocked(roomId)) {
             const message = await getLockedActionMessage(uid);
@@ -349,7 +530,7 @@ function overrideMessagingFunctions() {
     };
 
     Messaging.canViewMessage = async function (mids, roomId, uid) {
-        if (await User.isAdministrator(uid)) {
+        if (await canAccessAdminChats(uid)) {
             return Array.isArray(mids) ? mids.map(() => true) : true;
         }
         return await originalCanViewMessage(mids, roomId, uid);
@@ -358,9 +539,23 @@ function overrideMessagingFunctions() {
     if (typeof originalCanReply === 'function') {
         Messaging.canReply = async function (...args) {
             const guessed = guessRoomIdUidFromArgs(args);
-            if (await User.isAdministrator(guessed.uid)) {
+            const [isAdmin, canView, canManage] = await Promise.all([
+                User.isAdministrator(guessed.uid),
+                privileges.global.can(ADMIN_CHATS_PRIVILEGE, guessed.uid),
+                privileges.global.can(ADMIN_CHATS_MANAGE_PRIVILEGE, guessed.uid),
+            ]);
+            const isManager = isAdmin || canManage;
+            const hasAccess = isAdmin || canView || canManage;
+
+            if (isManager) {
                 return true;
             }
+            if (guessed.roomId && hasAccess) {
+                const isMember = await isUserMemberOfRoom(guessed.uid, guessed.roomId);
+                if (!isMember) {
+                    return false;
+                }
+            }
             if (guessed.roomId && await isRoomLocked(guessed.roomId)) {
                 return false;
             }
@@ -393,6 +588,15 @@ function registerRoutes(app, router, middleware) {
 
     const pageController = async (req, res, next) => {
         try {
+            // If user is not allowed, redirect to user-specific chat URL
+            if (req.uid && !await canAccessAdminChats(req.uid)) {
+                const userSlug = await User.getUserField(req.uid, 'userslug');
+                if (userSlug && req.params.roomId) {
+                    const redirectUrl = `${req.baseUrl || ''}/user/${userSlug}/chats/${req.params.roomId}${req.params.index ? `/${req.params.index}` : ''}`;
+                    return res.redirect(redirectUrl);
+                }
+            }
+            
             await renderAdminChatsPage(req, res, next);
         } catch (err) {
             next(err);
@@ -416,6 +620,25 @@ function registerRoutes(app, router, middleware) {
         }
     });
 
+    
+    router.get('/api/admin-chats/privileges', ...routeMiddleware, async (req, res) => {
+        try {
+            if (!await assertAdminChatsAccess(req, res)) {
+                return;
+            }
+
+            const isAdmin = await User.isAdministrator(req.uid);
+            const canManage = isAdmin || await privileges.global.can(ADMIN_CHATS_MANAGE_PRIVILEGE, req.uid);
+            res.json({
+                adminChatsAccess: true,
+                adminChatsCanManage: canManage,
+                adminChatsIsAdmin: isAdmin,
+            });
+        } 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)) {
@@ -438,8 +661,8 @@ function registerRoutes(app, router, middleware) {
                 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 User.isAdministrator(actingUid) && !await canManageAdminChats(actingUid)) {
+                return res.status(403).json({ status: { code: 'forbidden', message: 'Admin or manage privilege required' } });
             }
 
             if (!await roomExists(roomId)) {
@@ -480,7 +703,7 @@ async function renderAdminChatsPage(req, res, next) {
 }
 
 async function assertAdminChatsAccess(req, res) {
-    if (!req.uid || !await User.isAdministrator(req.uid)) {
+    if (!req.uid || !await canAccessAdminChats(req.uid)) {
         helpers.notAllowed(req, res);
         return false;
     }
@@ -490,6 +713,13 @@ async function assertAdminChatsAccess(req, res) {
 
 async function buildAdminChatsPayload(req) {
     const userslug = await User.getUserField(req.uid, 'userslug');
+    const [isAdmin, canView, canManage] = await Promise.all([
+        User.isAdministrator(req.uid),
+        privileges.global.can(ADMIN_CHATS_PRIVILEGE, req.uid),
+        privileges.global.can(ADMIN_CHATS_MANAGE_PRIVILEGE, req.uid),
+    ]);
+    const adminChatsManage = isAdmin || canManage;
+    const adminChatsAccess = isAdmin || canView || canManage;
     const [recentChats, publicRooms, privateRoomCount] = await Promise.all([
         getAdminRecentChats(req.uid, 0, ADMIN_CHAT_PAGE_SIZE),
         Messaging.getPublicRooms(req.uid, req.uid),
@@ -501,6 +731,9 @@ async function buildAdminChatsPayload(req) {
         uid: req.uid,
         userslug,
         adminAllChats: true,
+        adminChatsAccess,
+        adminChatsIsAdmin: isAdmin,
+        adminChatsCanManage: adminChatsManage,
         rooms: recentChats.rooms,
         nextStart: recentChats.nextStart,
         publicRooms: publicRooms || [],
@@ -697,6 +930,10 @@ async function canNonAdminModifyLockedRoom(uid, roomId) {
         return false;
     }
 
+    if (await canManageAdminChats(uid)) {
+        return false;
+    }
+
     return await isRoomLocked(roomId);
 }
 async function roomExists(roomId) {
@@ -833,4 +1070,3 @@ function getRoomId(payload) {
 }
 
 module.exports = plugin;
-

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "nodebb-plugin-admin-chats",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "A plugin that allows the administrator to view and manage user chats.",
   "main": "library.js",
-  "dependencies": {
-    "lodash": "^4.17.0"
-  },
   "nbbpm": {
-    "compatibility": "^3.0.0 || ^4.0.0"
+    "compatibility": "^4.0.0"
   }
 }

package/plugin.json

@@ -63,6 +63,19 @@
     {
       "hook": "filter:scripts.get",
       "method": "addScripts"
+    },
+    {
+      "hook": "filter:notifications.create",
+      "method": "filterNotificationCreate"
+    },
+    {
+      "hook": "filter:user.notifications.getNotifications",
+      "method": "filterUserNotificationsGetNotifications"
+    },
+    {
+      "hook": "static:privileges.global.init",
+      "method": "registerPrivileges"
     }
-  ]
+  ],
+  "languages": "public/languages"
 }

package/public/languages/en-GB/admin-chats.json

@@ -5,5 +5,7 @@
   "errors.update": "Unable to update room lock.",
   "profile.viewChats": "View Chats",
   "empty.selectChat": "Please select a chat from the sidebar.",
-  "errors.lockedAction": "This action cannot be performed in a locked room."
+  "errors.lockedAction": "This action cannot be performed in a locked room.",
+  "admin-chats-view": "View all chats",
+  "admin-chats-manage": "Manage chat rooms"
 }

package/public/languages/he/admin-chats.json

@@ -5,5 +5,7 @@
   "errors.update": "לא ניתן לעדכן את נעילת החדר.",
   "profile.viewChats": "צפיה בצ'אטים",
   "empty.selectChat": "אנא בחר צ'אט מסרגל הצד.",
-  "errors.lockedAction": "לא ניתן לבצע פעולה זו בחדר נעול"
+  "errors.lockedAction": "לא ניתן לבצע פעולה זו בחדר נעול",
+  "admin-chats-view": "צפיה בכל הצ'אטים",
+  "admin-chats-manage": "ניהול חדרי צ'אט"
 }