Node.js based forum software built for the modern web
'use strict';
const _ = require('lodash');
const db = require('../database');
const meta = require('../meta');
const posts = require('../posts');
const topics = require('../topics');
const categories = require('../categories');
const groups = require('../groups');
const user = require('../user');
const activitypub = require('../activitypub');
const helpers = require('./helpers');
const plugins = require('../plugins');
const utils = require('../utils');
const privsCategories = require('./categories');
const privsTopics = require('./topics');
const privsPosts = module.exports;
privsPosts.get = async function (pids, uid) {
if (!Array.isArray(pids) || !pids.length) {
return [];
}
const postData = await posts.getPostsFields(pids, ['tid', 'uid']);
const uniqTids = _.uniq(postData.map(p => p && p.tid).filter(Boolean));
const topicData = await topics.getTopicsFields(uniqTids, ['cid', 'uid', 'deleted', 'scheduled']);
const tidToTopic = _.zipObject(uniqTids, topicData);
const uniqueCids = _.uniq(topicData.map(t => t && t.cid).filter(Boolean));
const results = await utils.promiseParallel({
isAdmin: user.isAdministrator(uid),
isModerator: user.isModerator(uid, uniqueCids),
read: helpers.isAllowedTo('read', uid, uniqueCids),
'topics:read': helpers.isAllowedTo('topics:read', uid, uniqueCids),
'topics:schedule': helpers.isAllowedTo('topics:schedule', uid, uniqueCids),
'posts:edit': helpers.isAllowedTo('posts:edit', uid, uniqueCids),
'posts:history': helpers.isAllowedTo('posts:history', uid, uniqueCids),
'posts:view_deleted': helpers.isAllowedTo('posts:view_deleted', uid, uniqueCids),
categoryData: categories.getCategoriesFields(uniqueCids, ['disabled']),
});
const isModerator = _.zipObject(uniqueCids, results.isModerator);
const privData = {};
privData.read = _.zipObject(uniqueCids, results.read);
privData['topics:read'] = _.zipObject(uniqueCids, results['topics:read']);
privData['topics:schedule'] = _.zipObject(uniqueCids, results['topics:schedule']);
privData['posts:edit'] = _.zipObject(uniqueCids, results['posts:edit']);
privData['posts:history'] = _.zipObject(uniqueCids, results['posts:history']);
privData['posts:view_deleted'] = _.zipObject(uniqueCids, results['posts:view_deleted']);
privData.disabled = _.zipObject(uniqueCids, results.categoryData.map(c => c && c.disabled));
const privileges = postData.map((post, i) => {
const topic = tidToTopic[post.tid] || {};
const { cid } = topic;
const isPostOwner = String(post.uid) === String(uid);
const isTopicOwner = String(topic.uid) === String(uid);
const isAdminOrMod = results.isAdmin || isModerator[cid];
const editable = (privData['posts:edit'][cid] && (isPostOwner || results.isModerator[i])) || results.isAdmin;
const viewDeletedPosts = isPostOwner || privData['posts:view_deleted'][cid] || results.isAdmin;
const viewHistory = isPostOwner || privData['posts:history'][cid] || results.isAdmin;
const canViewDeletedScheduled = privsTopics.canViewDeletedScheduled(topic, {
view_deleted: results.isAdmin || isTopicOwner || privData['posts:view_deleted'][cid],
view_scheduled: results.isAdmin || privData['topics:schedule'][cid],
});
return {
editable: editable,
move: isAdminOrMod,
isAdminOrMod: isAdminOrMod,
'topics:read': results.isAdmin || (privData['topics:read'][cid] && canViewDeletedScheduled),
read: privData.read[cid] || results.isAdmin,
'posts:history': viewHistory,
'posts:view_deleted': viewDeletedPosts,
disabled: privData.disabled[cid],
};
});
return privileges;
};
privsPosts.can = async function (privilege, pid, uid) {
const cid = await posts.getCidByPid(pid);
return await privsCategories.can(privilege, cid, uid);
};
privsPosts.filter = async function (privilege, pids, uid) {
if (!Array.isArray(pids) || !pids.length) {
return [];
}
pids = _.uniq(pids);
const postData = await posts.getPostsFields(pids, ['uid', 'tid', 'deleted']);
const tids = _.uniq(postData.map(post => post && post.tid).filter(Boolean));
const topicData = await topics.getTopicsFields(tids, ['deleted', 'scheduled', 'cid']);
const tidToTopic = _.zipObject(tids, topicData);
let cids = postData.map((post, index) => {
if (post) {
post.pid = pids[index];
post.topic = tidToTopic[post.tid];
}
return tidToTopic[post.tid] && tidToTopic[post.tid].cid;
}).filter(cid => utils.isNumber(cid) ? parseInt(cid, 10) : cid);
cids = _.uniq(cids);
const results = await privsCategories.getBase(privilege, cids, uid);
const allowedCids = cids.filter((cid, index) => !results.categories[index].disabled &&
(results.allowedTo[index] || results.isAdmin));
const cidsSet = new Set(allowedCids);
const canViewDeleted = _.zipObject(cids, results.view_deleted);
const canViewScheduled = _.zipObject(cids, results.view_scheduled);
pids = postData.filter(post => (
post.topic &&
cidsSet.has(post.topic.cid) &&
(privsTopics.canViewDeletedScheduled({
deleted: post.topic.deleted || post.deleted,
scheduled: post.topic.scheduled,
}, {}, canViewDeleted[post.topic.cid], canViewScheduled[post.topic.cid]) || results.isAdmin)
)).map(post => post.pid);
const data = await plugins.hooks.fire('filter:privileges.posts.filter', {
privilege: privilege,
uid: uid,
pids: pids,
});
return data ? data.pids : null;
};
privsPosts.canRead = async function (pid, uid) {
const tid = await posts.getPostField(pid, 'tid');
return await privsTopics.canRead(tid, uid);
};
privsPosts.canEdit = async function (pid, uid) {
const isRemote = activitypub.helpers.isUri(pid);
const results = await utils.promiseParallel({
isAdmin: user.isAdministrator(uid),
isMod: posts.isModerator([pid], uid),
isOwner: posts.isOwner(pid, uid),
isEditor: db.isSetMember(`pid:${pid}:editors`, uid),
isGroupEditor: isGroupEditor(pid, uid),
edit: privsPosts.can('posts:edit', pid, uid),
postData: posts.getPostFields(pid, ['tid', 'timestamp', 'deleted', 'deleterUid']),
userData: user.getUserFields(uid, ['reputation']),
});
if (!results.postData.tid) {
return { flag: false, message: '[[error:no-post]]' };
}
results.isMod = results.isMod[0];
if (results.isAdmin) {
return { flag: true };
}
if (
!isRemote && !results.isMod &&
meta.config.postEditDuration &&
(Date.now() - results.postData.timestamp > meta.config.postEditDuration * 1000)
) {
return { flag: false, message: `[[error:post-edit-duration-expired, ${meta.config.postEditDuration}]]` };
}
if (
!isRemote && !results.isMod &&
meta.config.newbiePostEditDuration > 0 &&
meta.config.newbieReputationThreshold > results.userData.reputation &&
Date.now() - results.postData.timestamp > meta.config.newbiePostEditDuration * 1000
) {
return { flag: false, message: `[[error:post-edit-duration-expired, ${meta.config.newbiePostEditDuration}]]` };
}
results.isLocked = await topics.isLocked(results.postData.tid);
results.pid = utils.isNumber(pid) ? parseInt(pid, 10) : pid;
results.uid = uid;
// Fired ahead of the lock and deleted-post gates, so that plugins can grant
// edit access inside a locked topic by unsetting `isLocked`.
const result = await plugins.hooks.fire('filter:privileges.posts.edit', results);
if (!result.isMod && result.isLocked) {
return { flag: false, message: '[[error:topic-locked]]' };
}
if (!result.isMod && result.postData.deleted && parseInt(uid, 10) !== parseInt(result.postData.deleterUid, 10)) {
return { flag: false, message: '[[error:post-deleted]]' };
}
return {
flag: result.edit && (result.isOwner || result.isEditor || result.isGroupEditor || result.isMod),
message: '[[error:no-privileges]]',
};
};
async function isGroupEditor(pid, uid) {
const groupNames = await db.getSetMembers(`pid:${pid}:editors:groups`);
if (!groupNames.length) {
return false;
}
return await groups.isMemberOfAny(uid, groupNames);
}
privsPosts.canDelete = async function (pid, uid) {
const postData = await posts.getPostFields(pid, ['uid', 'tid', 'timestamp', 'deleterUid']);
const results = await utils.promiseParallel({
isAdmin: user.isAdministrator(uid),
isMod: posts.isModerator([pid], uid),
isLocked: topics.isLocked(postData.tid),
isOwner: posts.isOwner(pid, uid),
'posts:delete': privsPosts.can('posts:delete', pid, uid),
});
results.isMod = results.isMod[0];
if (results.isAdmin) {
return { flag: true };
}
results.pid = utils.isNumber(pid) ? parseInt(pid, 10) : pid;
results.uid = uid;
results.postData = postData;
// Fired ahead of the lock and delete-duration gates, so that plugins can
// grant delete access inside a locked topic by unsetting `isLocked`.
const result = await plugins.hooks.fire('filter:privileges.posts.delete', results);
if (!result.isMod && result.isLocked) {
return { flag: false, message: '[[error:topic-locked]]' };
}
const { postDeleteDuration } = meta.config;
if (!result.isMod && postDeleteDuration && (Date.now() - postData.timestamp > postDeleteDuration * 1000)) {
return { flag: false, message: `[[error:post-delete-duration-expired, ${meta.config.postDeleteDuration}]]` };
}
const { deleterUid } = postData;
const flag = result['posts:delete'] && ((result.isOwner && (deleterUid === 0 || deleterUid === postData.uid)) || result.isMod);
return { flag: flag, message: '[[error:no-privileges]]' };
};
privsPosts.canFlag = async function (pid, uid) {
const targetUid = await posts.getPostField(pid, 'uid');
const [userReputation, isAdminOrModerator, targetPrivileged, reporterPrivileged] = await Promise.all([
user.getUserField(uid, 'reputation'),
isAdminOrMod(pid, uid),
user.isPrivileged(targetUid),
user.isPrivileged(uid),
]);
const minimumReputation = meta.config['min:rep:flag'];
let canFlag = isAdminOrModerator || (userReputation >= minimumReputation);
if (targetPrivileged && !reporterPrivileged) {
canFlag = false;
}
return { flag: canFlag };
};
privsPosts.canMove = async function (pid, uid) {
const isMain = await posts.isMain(pid);
if (isMain) {
throw new Error('[[error:cant-move-mainpost]]');
}
return await isAdminOrMod(pid, uid);
};
privsPosts.canPurge = async function (pid, uid) {
const cid = await posts.getCidByPid(pid);
const results = await utils.promiseParallel({
purge: privsCategories.isUserAllowedTo('purge', cid, uid),
owner: posts.isOwner(pid, uid),
isAdmin: user.isAdministrator(uid),
isModerator: user.isModerator(uid, cid),
});
// Allow remote posts to purge themselves (as:Delete received)
if (activitypub.helpers.isUri(pid) && results.owner) {
results.purge = true;
}
return (results.purge && (results.owner || results.isModerator)) || results.isAdmin;
};
async function isAdminOrMod(pid, uid) {
if (parseInt(uid, 10) <= 0) {
return false;
}
const cid = await posts.getCidByPid(pid);
return await privsCategories.isAdminOrMod(cid, uid);
}