nodebb-plugin-admin-chats 3.5.0 → 3.5.1

package/README.md

@@ -16,7 +16,13 @@ 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 version `^4.0.0`
+* **Compatibility**: NodeBB version `^4.0.0` (tested through 4.14)
+
+### Code Layout
+* `library.js` — thin entry point; wires together the modules below.
+* `lib/access.js`, `lib/lock.js`, `lib/history.js`, `lib/hooks.js`, `lib/routes.js`, `lib/overrides.js` — server-side logic, split by concern.
+* `templates/partials/chats/*.tpl` — overrides of core's chat partials (controls menu, message actions, empty state, recent-room list) so the lock UI, participants line and admin menu item render server-side instead of being built with client-side DOM manipulation.
+* `static/lib/switch-chat.js`, `static/lib/lock-toggle.js`, `static/lib/live-updates.js` — client-side: admin room routing, the lock/unlock click handler, and live updates pushed over a targeted socket event when a room's lock state changes.
 
 ### Permissions
 The plugin exposes two global permissions in the ACP:
@@ -63,12 +69,11 @@ The plugin overrides core messaging functions to ensure full administrative cont
 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.
+Lock state, the admin menu item, the empty-state copy and the participants line are all rendered server-side via the template overrides in `templates/partials/chats/`, using NodeBB's own translation system (`[[admin-chats:...]]` / `tx()`) — no client-side DOM injection or language sniffing. The `static/lib/` scripts handle the parts that have no server-side extension point:
+* Routing chat-room switches through the admin API when viewing the all-chats admin page (`static/lib/switch-chat.js`).
+* Wiring the lock/unlock menu item's click handler (`static/lib/lock-toggle.js`).
+* Pushing live updates to anyone with an affected room open, via a `event:admin-chats.roomLockChanged` socket broadcast, instead of polling (`static/lib/live-updates.js`).
+* Injecting the "View Chats" link into the profile action menu (`static/lib/profile-link.js`) — this one *is* DOM injection, and deliberately so: the account menu is a theme template (e.g. nodebb-theme-harmony's `partials/account/admin-menu.tpl`) with a hardcoded item list and no hook over it, unlike the chat templates above which core lets a plugin override by file path.
 
 ---
 *Developed by [palmoni5](https://github.com/palmoni5/nodebb-plugin-admin-chats).* 

package/lib/access.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const User = nodebb.require('./src/user');
+const privileges = nodebb.require('./src/privileges');
+const db = nodebb.require('./src/database');
+
+const ADMIN_CHATS_PRIVILEGE = 'admin-chats:view';
+const ADMIN_CHATS_MANAGE_PRIVILEGE = 'admin-chats:manage';
+
+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);
+}
+
+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)
+    );
+}
+
+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],
+    };
+}
+
+module.exports = {
+    ADMIN_CHATS_PRIVILEGE,
+    ADMIN_CHATS_MANAGE_PRIVILEGE,
+    canAccessAdminChats,
+    canManageAdminChats,
+    isUserMemberOfRoom,
+    getCallerUid,
+    getRoomId,
+    guessRoomIdUidFromArgs,
+};

package/lib/history.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const validator = nodebb.require('validator');
+const Messaging = nodebb.require('./src/messaging');
+const User = nodebb.require('./src/user');
+const db = nodebb.require('./src/database');
+
+function editHistoryKey(mid) {
+    return `message:${mid}:editHistory`;
+}
+
+async function getMessageEditHistory(mid) {
+    const [exists, current, rawHistory] = await Promise.all([
+        Messaging.messageExists(mid),
+        Messaging.getMessageFields(mid, ['content', 'fromuid', 'timestamp', 'edited', 'roomId', 'deleted']),
+        db.getListRange(editHistoryKey(mid), 0, -1),
+    ]);
+
+    const revisions = (rawHistory || []).map((item) => {
+        try {
+            return JSON.parse(item);
+        } catch (err) {
+            return null;
+        }
+    }).filter(Boolean);
+
+    const uidSet = new Set();
+    const authorUid = parseInt(current && current.fromuid, 10) || 0;
+    if (authorUid) {
+        uidSet.add(authorUid);
+    }
+    revisions.forEach((rev) => {
+        if (rev.editedByUid) {
+            uidSet.add(parseInt(rev.editedByUid, 10) || 0);
+        }
+        if (rev.fromuid) {
+            uidSet.add(parseInt(rev.fromuid, 10) || 0);
+        }
+    });
+    uidSet.delete(0);
+
+    const uids = [...uidSet];
+    const userMap = new Map();
+    if (uids.length) {
+        const users = await User.getUsersFields(uids, ['uid', 'username', 'userslug']);
+        uids.forEach((uid, index) => {
+            if (users[index]) {
+                userMap.set(uid, users[index]);
+            }
+        });
+    }
+
+    const decorate = (uid) => {
+        const numeric = parseInt(uid, 10) || 0;
+        const user = userMap.get(numeric);
+        return {
+            uid: numeric,
+            username: user ? user.username : (numeric ? `uid ${numeric}` : '—'),
+        };
+    };
+
+    return {
+        mid,
+        exists: !!exists,
+        roomId: parseInt(current && current.roomId, 10) || 0,
+        author: decorate(authorUid),
+        current: {
+            content: current ? String(current.content || '') : '',
+            edited: parseInt(current && current.edited, 10) || 0,
+            timestamp: parseInt(current && current.timestamp, 10) || 0,
+            deleted: parseInt(current && current.deleted, 10) === 1,
+        },
+        revisionCount: revisions.length,
+        revisions: revisions.map(rev => ({
+            content: String(rev.content || ''),
+            editor: decorate(rev.editedByUid),
+            replacedAt: parseInt(rev.replacedAt, 10) || 0,
+            previousEdited: parseInt(rev.previousEdited, 10) || 0,
+        })),
+    };
+}
+
+function renderMessageHistoryHtml(history) {
+    const esc = value => validator.escape(String(value == null ? '' : value));
+    const fmt = (ts) => {
+        const numeric = parseInt(ts, 10) || 0;
+        return numeric ? new Date(numeric).toISOString().replace('T', ' ').replace(/\..+$/, ' UTC') : '—';
+    };
+
+    if (!history.exists) {
+        return `<!doctype html><html lang="he" dir="rtl"><meta charset="utf-8"><title>היסטוריית עריכות</title><body style="font-family:system-ui,Arial,sans-serif;padding:2rem;">
+            <h1>הודעה ${esc(history.mid)} לא נמצאה</h1></body></html>`;
+    }
+
+    const timeline = history.revisions.map((rev, index) => `
+        <li class="rev">
+            <div class="meta">גרסה ${index + 1} · הוחלפה ב-${esc(fmt(rev.replacedAt))} · עורך: ${esc(rev.editor.username)}</div>
+            <pre class="content">${esc(rev.content)}</pre>
+        </li>`).join('');
+
+    const currentBlock = `
+        <li class="rev current">
+            <div class="meta">גרסה נוכחית${history.current.edited ? ` · נערכה לאחרונה ${esc(fmt(history.current.edited))}` : ''}${history.current.deleted ? ' · מחוקה' : ''}</div>
+            <pre class="content">${esc(history.current.content)}</pre>
+        </li>`;
+
+    return `<!doctype html>
+<html lang="he" dir="rtl">
+<head>
+<meta charset="utf-8">
+<meta name="robots" content="noindex,nofollow">
+<title>היסטוריית עריכות · הודעה ${esc(history.mid)}</title>
+<style>
+    body { font-family: system-ui, Segoe UI, Arial, sans-serif; margin: 0; padding: 2rem; background: #f5f6f8; color: #1c1e21; }
+    h1 { font-size: 1.25rem; margin: 0 0 .25rem; }
+    .sub { color: #65676b; font-size: .875rem; margin-bottom: 1.5rem; }
+    ul { list-style: none; margin: 0; padding: 0; max-width: 780px; }
+    .rev { background: #fff; border: 1px solid #dcdfe3; border-radius: 8px; padding: .75rem 1rem; margin-bottom: 1rem; }
+    .rev.current { border-color: #2d6cdf; box-shadow: 0 0 0 1px #2d6cdf33; }
+    .meta { font-size: .8rem; color: #65676b; margin-bottom: .5rem; }
+    .content { white-space: pre-wrap; word-break: break-word; margin: 0; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .9rem; }
+    @media (prefers-color-scheme: dark) {
+        body { background: #18191a; color: #e4e6eb; }
+        .rev { background: #242526; border-color: #3a3b3c; }
+        .meta, .sub { color: #b0b3b8; }
+    }
+</style>
+</head>
+<body>
+    <h1>היסטוריית עריכות · הודעה ${esc(history.mid)}</h1>
+    <div class="sub">מחבר: ${esc(history.author.username)} · חדר: ${esc(history.roomId)} · ${esc(history.revisionCount)} עריכות קודמות</div>
+    <ul>
+        ${history.revisionCount ? timeline : '<li class="rev"><div class="meta">אין עריכות קודמות מתועדות</div></li>'}
+        ${currentBlock}
+    </ul>
+</body>
+</html>`;
+}
+
+module.exports = {
+    editHistoryKey,
+    getMessageEditHistory,
+    renderMessageHistoryHtml,
+};

package/lib/hooks.js

@@ -0,0 +1,310 @@
+'use strict';
+
+const User = nodebb.require('./src/user');
+const Messaging = nodebb.require('./src/messaging');
+const db = nodebb.require('./src/database');
+const privileges = nodebb.require('./src/privileges');
+
+const {
+    ADMIN_CHATS_PRIVILEGE, ADMIN_CHATS_MANAGE_PRIVILEGE,
+    canAccessAdminChats, canManageAdminChats, isUserMemberOfRoom, getCallerUid, getRoomId,
+} = require('./access');
+const {
+    isRoomLocked, getRoomLockData, canNonAdminModifyLockedRoom,
+    ensureFirstVisibleMessageHeader, buildRoomMessagesWithLockNotice, markMessagesLocked,
+} = require('./lock');
+
+const LOCKED_ACTION_ERROR = '[[admin-chats:errors.lockedAction]]';
+
+const hooks = {};
+
+hooks.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;
+};
+
+hooks.filterNotificationCreate = async function (data) {
+    if (!data || !data.data) {
+        return data;
+    }
+
+    const notification = data.data;
+    const chatMatch = notification.path && notification.path.match(/^\/chats\/(\d+)(?:\/(\d+))?$/);
+    if (chatMatch && notification.uid) {
+        const roomId = chatMatch[1];
+        const index = chatMatch[2];
+        const userSlug = await User.getUserField(notification.uid, 'userslug');
+        if (userSlug) {
+            notification.path = `/user/${userSlug}/chats/${roomId}${index ? `/${index}` : ''}`;
+        }
+    }
+
+    return data;
+};
+
+hooks.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 || userPathRegex.test(notification.path)) {
+            return;
+        }
+        const match = notification.path.match(chatPathRegex);
+        if (!match) {
+            return;
+        }
+        const replacement = `/user/${userSlug}/chats/${match[1]}${match[2] ? `/${match[2]}` : ''}`;
+        notification.path = notification.path.replace(chatPathRegex, replacement);
+    });
+
+    return data;
+};
+
+// data.uid here is the profile OWNER being viewed, not the viewer — the
+// viewer is data.callerUID (src/controllers/accounts/helpers.js's
+// getProfileMenu). Core builds each link's url itself from `route`
+// (relative to /user/<profile-owner-slug>/), so there's no need to resolve
+// the slug or build the path here.
+hooks.addProfileLink = async function (data) {
+    const viewerUid = data && data.callerUID;
+    if (!viewerUid || !await canAccessAdminChats(viewerUid)) {
+        return data;
+    }
+
+    data.links.push({
+        id: 'admin-view-chats',
+        route: 'chats',
+        icon: 'fa-comments',
+        name: '[[admin-chats:profile.viewChats]]',
+        visibility: {
+            self: true, other: true, moderator: true, globalMod: true, admin: true,
+        },
+    });
+
+    return data;
+};
+
+hooks.isRoomOwner = async function (payload) {
+    const [isAdmin, canManage] = await Promise.all([
+        User.isAdministrator(payload.uid),
+        canManageAdminChats(payload.uid),
+    ]);
+    if (isAdmin || canManage) {
+        payload.isOwner = true;
+    }
+    return payload;
+};
+
+hooks.isUserInRoom = async function (payload) {
+    const uid = getCallerUid(payload);
+    if (await canAccessAdminChats(uid)) {
+        payload.inRoom = true;
+    }
+    return payload;
+};
+
+hooks.canReply = async function (payload) {
+    const uid = getCallerUid(payload);
+    const roomId = getRoomId(payload);
+
+    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 && !await isUserMemberOfRoom(uid, roomId)) {
+        payload.canReply = false;
+        return payload;
+    }
+
+    if (roomId && await isRoomLocked(roomId)) {
+        payload.canReply = false;
+    }
+
+    return payload;
+};
+
+hooks.filterMessagingSend = async function (payload) {
+    const uid = getCallerUid(payload);
+    const roomId = getRoomId(payload);
+
+    if (!uid || !roomId) {
+        return payload;
+    }
+
+    if (await User.isAdministrator(uid) || await canManageAdminChats(uid)) {
+        return payload;
+    }
+
+    if (await canAccessAdminChats(uid) && !await isUserMemberOfRoom(uid, roomId)) {
+        throw new Error('[[error:no-privileges]]');
+    }
+
+    if (await isRoomLocked(roomId)) {
+        throw new Error(LOCKED_ACTION_ERROR);
+    }
+
+    return payload;
+};
+
+async function guardRoomModification(payload) {
+    if (await canManageAdminChats(payload.uid)) {
+        return payload;
+    }
+    if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
+        throw new Error(LOCKED_ACTION_ERROR);
+    }
+    return payload;
+}
+
+hooks.filterAddUsersToRoom = guardRoomModification;
+hooks.filterRemoveUsersFromRoom = guardRoomModification;
+hooks.filterRenameRoom = guardRoomModification;
+
+hooks.canGetMessages = async function (payload) {
+    if (await canAccessAdminChats(payload.callerUid)) {
+        payload.canGet = true;
+    }
+    return payload;
+};
+
+hooks.canGetRecentChats = async function (payload) {
+    if (await canAccessAdminChats(payload.callerUid)) {
+        payload.canGet = true;
+    }
+    return payload;
+};
+
+hooks.canGetPublicChats = async function (payload) {
+    if (await canAccessAdminChats(payload.callerUid)) {
+        payload.canGet = true;
+    }
+    return payload;
+};
+
+hooks.onLoadRoom = async function (payload) {
+    const { uid, room } = payload;
+    if (!room) {
+        return payload;
+    }
+
+    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 && !isManager;
+
+    room.adminChatLock = lockData;
+    room.adminChatLockedForViewer = isLockedForUser;
+    room.messages = markMessagesLocked(
+        ensureFirstVisibleMessageHeader(buildRoomMessagesWithLockNotice(room.messages, lockData)),
+        isLockedForUser
+    );
+    room.canReply = room.canReply && !isLockedForUser;
+    room.showUserInput = room.showUserInput && !isLockedForUser;
+
+    if (!hasAccess) {
+        return payload;
+    }
+
+    const isOfficialMember = await isUserMemberOfRoom(uid, room.roomId);
+
+    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 = parseInt(await db.getObjectField(`chat:room:${room.roomId}`, 'messageCount'), 10) || 0;
+
+            messages.forEach((msg, index) => {
+                msg.index = messageCount - index - 1;
+            });
+
+            room.messages = markMessagesLocked(
+                ensureFirstVisibleMessageHeader(buildRoomMessagesWithLockNotice(messages.reverse(), lockData)),
+                isLockedForUser
+            );
+
+            room.messages.forEach((msg, index) => {
+                if (index === 0) {
+                    msg.newSet = true;
+                } else {
+                    const prevMsg = room.messages[index - 1];
+                    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);
+        }
+    }
+
+    if (!isManager && !isOfficialMember) {
+        room.canReply = false;
+        room.showUserInput = false;
+    }
+
+    room.isAdmin = isManager;
+    room.isAdminOrGlobalMod = isManager;
+    payload.isAdminOrGlobalMod = isManager;
+    if (isManager) {
+        room.isOwner = true;
+    }
+
+    return payload;
+};
+
+module.exports = hooks;