Skip to content

Node.js based forum software built for the modern web

10.6 KB
Raw Blame

'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);
}