nodebb-plugin-admin-chats 3.4.3 → 3.5.1

package/lib/lock.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const db = nodebb.require('./src/database');
+const User = nodebb.require('./src/user');
+const { canManageAdminChats } = require('./access');
+
+// Marker type on the synthetic system message this plugin injects when a
+// room is locked — mirrors how core tags its own system messages
+// ('user-join', 'user-leave', ...) instead of sniffing message content.
+const LOCK_MESSAGE_TYPE = 'admin-chat-lock';
+
+async function roomExists(roomId) {
+    const roomData = await db.getObject(`chat:room:${roomId}`);
+    return !!roomData;
+}
+
+async function lockRoom(roomId, actingUid) {
+    await db.setObject(`chat:room:${roomId}:adminLock`, {
+        isLocked: 1,
+        lockedBy: actingUid,
+        lockedAt: Date.now(),
+    });
+
+    return await getRoomLockData(roomId);
+}
+
+async function unlockRoom(roomId, actingUid) {
+    await db.setObject(`chat:room:${roomId}:adminLock`, {
+        isLocked: 0,
+        lockedBy: actingUid,
+        lockedAt: 0,
+    });
+
+    return await getRoomLockData(roomId);
+}
+
+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`) || {};
+    return {
+        isLocked: data.isLocked === '1' || data.isLocked === 1 || data.isLocked === true,
+        lockedBy: parseInt(data.lockedBy, 10) || 0,
+        lockedAt: parseInt(data.lockedAt, 10) || 0,
+    };
+}
+
+async function canNonAdminModifyLockedRoom(uid, roomId) {
+    if (!uid || !roomId) {
+        return false;
+    }
+
+    if (await User.isAdministrator(uid)) {
+        return false;
+    }
+
+    if (await canManageAdminChats(uid)) {
+        return false;
+    }
+
+    return await isRoomLocked(roomId);
+}
+
+function isAdminLockMessage(msg) {
+    return !!(msg && msg.type === LOCK_MESSAGE_TYPE);
+}
+
+function stripAdminLockMessages(messages) {
+    const list = Array.isArray(messages) ? messages.slice() : [];
+    return list.filter(msg => !isAdminLockMessage(msg));
+}
+
+function ensureFirstVisibleMessageHeader(messages) {
+    const list = Array.isArray(messages) ? messages.slice() : [];
+    const firstUserMessageIndex = list.findIndex(msg => msg && !msg.system);
+
+    if (firstUserMessageIndex !== -1) {
+        list[firstUserMessageIndex].newSet = true;
+    }
+
+    return list;
+}
+
+// Marks every message rendered while the room is locked with `adminChatLocked`
+// so partials/chats/message.tpl can hide edit/delete/restore for non-managers
+// without a client-side visibility pass.
+function markMessagesLocked(messages, isLockedForViewer) {
+    if (!isLockedForViewer) {
+        return messages;
+    }
+    (messages || []).forEach((msg) => {
+        if (msg && !msg.system) {
+            msg.adminChatLocked = true;
+        }
+    });
+    return messages;
+}
+
+function buildRoomMessagesWithLockNotice(messages, lockData) {
+    const cleanedMessages = stripAdminLockMessages(messages);
+    if (!lockData || !lockData.isLocked || !lockData.lockedAt) {
+        return cleanedMessages;
+    }
+
+    cleanedMessages.push({
+        // Raw translation token, resolved per-viewer at render time by
+        // partials/chats/system-message.tpl's {{tx(messages.content)}} —
+        // the same pattern core uses for its own system messages
+        // (src/messaging/create.js: Messaging.addSystemMessage).
+        content: '[[admin-chats:lock.banner]]',
+        type: LOCK_MESSAGE_TYPE,
+        fromuid: lockData.lockedBy,
+        uid: lockData.lockedBy,
+        timestamp: lockData.lockedAt,
+        datetime: lockData.lockedAt,
+        system: true,
+        newSet: true,
+    });
+
+    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 cleanedMessages;
+}
+
+module.exports = {
+    LOCK_MESSAGE_TYPE,
+    roomExists,
+    lockRoom,
+    unlockRoom,
+    isRoomLocked,
+    getRoomLockData,
+    canNonAdminModifyLockedRoom,
+    isAdminLockMessage,
+    stripAdminLockMessages,
+    ensureFirstVisibleMessageHeader,
+    markMessagesLocked,
+    buildRoomMessagesWithLockNotice,
+};

package/lib/overrides.js

@@ -0,0 +1,186 @@
+'use strict';
+
+// Monkey-patches on core modules. NodeBB 4.14 has no hook for "room is
+// locked" style reply/edit/delete restriction or for intercepting chat
+// room-switch routing, so wrapping these functions is still the only way to
+// enforce admin-chat locks and custom admin routing.
+
+const User = nodebb.require('./src/user');
+const Messaging = nodebb.require('./src/messaging');
+const ChatsAPI = nodebb.require('./src/api/chats');
+const db = nodebb.require('./src/database');
+const {
+    canManageAdminChats, canAccessAdminChats, guessRoomIdUidFromArgs, isUserMemberOfRoom,
+    ADMIN_CHATS_PRIVILEGE, ADMIN_CHATS_MANAGE_PRIVILEGE,
+} = require('./access');
+const { isRoomLocked } = require('./lock');
+const { editHistoryKey } = require('./history');
+const privileges = nodebb.require('./src/privileges');
+
+// NodeBB translates `[[namespace:key]]` error messages itself (both in
+// app.alertError on the client and anywhere else the message surfaces) —
+// no need to resolve the string server-side for the acting user's language.
+const LOCKED_ACTION_ERROR = '[[admin-chats:errors.lockedAction]]';
+
+async function getMessageRoomId(messageId) {
+    const roomId = await db.getObjectField(`message:${messageId}`, 'roomId');
+    return parseInt(roomId, 10) || 0;
+}
+
+function overrideCoreChatRedirect(controllers, renderAdminChatsPage) {
+    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 canAccessAdminChats(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) {
+        const isSelfKick = caller && data && data.roomId && Array.isArray(data.uids) &&
+            data.uids.length === 1 && parseInt(data.uids[0], 10) === parseInt(caller.uid, 10);
+
+        if (isSelfKick && !await User.isAdministrator(caller.uid) && !await canManageAdminChats(caller.uid) &&
+            await isRoomLocked(data.roomId)) {
+            throw new Error(LOCKED_ACTION_ERROR);
+        }
+
+        return await originalKick.call(this, caller, data);
+    };
+
+    wrappedKick._adminChatLockWrapped = true;
+    ChatsAPI.kick = wrappedKick;
+}
+
+function overrideMessagingFunctions() {
+    const originalCanEdit = Messaging.canEdit;
+    const originalCanDelete = Messaging.canDelete;
+    const originalCanViewMessage = Messaging.canViewMessage;
+    const originalCanReply = Messaging.canReply;
+
+    if (typeof Messaging.editMessage === 'function' && !Messaging.editMessage._adminChatsHistoryWrapped) {
+        const originalEditMessage = Messaging.editMessage;
+
+        const wrappedEditMessage = async function (uid, mid, roomId, content) {
+            let previous = null;
+            try {
+                const [oldContent, fields] = await Promise.all([
+                    Messaging.getMessageField(mid, 'content'),
+                    Messaging.getMessageFields(mid, ['fromuid', 'timestamp', 'edited']),
+                ]);
+                // Only snapshot when the content actually changes, mirroring core's
+                // no-op short-circuit so history stays in step with real edits.
+                if (typeof oldContent === 'string' && oldContent !== content) {
+                    previous = {
+                        content: oldContent,
+                        fromuid: parseInt(fields && fields.fromuid, 10) || 0,
+                        editedByUid: parseInt(uid, 10) || 0,
+                        replacedAt: Date.now(),
+                        previousEdited: parseInt(fields && fields.edited, 10) ||
+                            parseInt(fields && fields.timestamp, 10) || 0,
+                    };
+                }
+            } catch (err) {
+                previous = null;
+            }
+
+            const result = await originalEditMessage.call(this, uid, mid, roomId, content);
+
+            if (previous) {
+                try {
+                    await db.listAppend(editHistoryKey(mid), JSON.stringify(previous));
+                } catch (err) {
+                    // History is best-effort; never break an edit because of it.
+                }
+            }
+
+            return result;
+        };
+
+        wrappedEditMessage._adminChatsHistoryWrapped = true;
+        Messaging.editMessage = wrappedEditMessage;
+    }
+
+    Messaging.canEdit = async function (messageId, uid) {
+        if (await User.isAdministrator(uid) || await canManageAdminChats(uid)) {
+            return true;
+        }
+
+        const roomId = await getMessageRoomId(messageId);
+        if (roomId && await isRoomLocked(roomId)) {
+            throw new Error(LOCKED_ACTION_ERROR);
+        }
+
+        return await originalCanEdit(messageId, uid);
+    };
+
+    Messaging.canDelete = async function (messageId, uid) {
+        if (await User.isAdministrator(uid) || await canManageAdminChats(uid)) {
+            return true;
+        }
+
+        const roomId = await getMessageRoomId(messageId);
+        if (roomId && await isRoomLocked(roomId)) {
+            throw new Error(LOCKED_ACTION_ERROR);
+        }
+
+        return await originalCanDelete(messageId, uid);
+    };
+
+    Messaging.canViewMessage = async function (mids, roomId, uid) {
+        if (await canAccessAdminChats(uid)) {
+            return Array.isArray(mids) ? mids.map(() => true) : true;
+        }
+        return await originalCanViewMessage(mids, roomId, uid);
+    };
+
+    if (typeof originalCanReply === 'function') {
+        Messaging.canReply = async function (...args) {
+            const guessed = guessRoomIdUidFromArgs(args);
+            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;
+            }
+            return await originalCanReply.apply(this, args);
+        };
+    }
+}
+
+module.exports = {
+    getMessageRoomId,
+    overrideCoreChatRedirect,
+    overrideChatsApi,
+    overrideMessagingFunctions,
+};