Skip to content

Node.js based forum software built for the modern web

4.0 KB
Raw Blame
'use strict';

const db = require('../database');
const plugins = require('../plugins');
const cacheCreate = require('../cache/lru');

module.exports = function (User) {
	User.blocks = {
		_cache: cacheCreate({
			name: 'user-blocks',
			max: 100,
			ttl: 0,
		}),
	};

	User.blocks.is = async function (targetUid, uids) {
		const isArray = Array.isArray(uids);
		uids = isArray ? uids : [uids];
		const blocks = await User.blocks.list(uids);
		targetUid = String(targetUid);
		const isBlocked = uids.map(
			(uid, index) => blocks[index] && blocks[index].includes(targetUid)
		);
		return isArray ? isBlocked : isBlocked[0];
	};

	User.blocks.can = async function (callerUid, blockerUid, blockeeUid, type) {
		// Guests can't block
		if (blockerUid === 0 || blockeeUid === 0) {
			throw new Error('[[error:cannot-block-guest]]');
		} else if (blockerUid === blockeeUid) {
			throw new Error('[[error:cannot-block-self]]');
		}

		// Administrators and global moderators cannot be blocked
		// Only admins/mods can block users as another user
		const [isCallerAdminOrMod, isBlockeeAdminOrMod] = await Promise.all([
			User.isAdminOrGlobalMod(callerUid),
			User.isAdminOrGlobalMod(blockeeUid),
		]);
		if (isBlockeeAdminOrMod && type === 'block') {
			throw new Error('[[error:cannot-block-privileged]]');
		}
		if (parseInt(callerUid, 10) !== parseInt(blockerUid, 10) && !isCallerAdminOrMod) {
			throw new Error('[[error:no-privileges]]');
		}
	};

	User.blocks.list = async function (uids) {
		const isArray = Array.isArray(uids);
		uids = (isArray ? uids : [uids]).map(uid => String(uid));

		const cachedData = await User.blocks._cache.getMany(uids, async (unCachedUids) => {
			const unCachedData = await db.getSortedSetsMembers(
				unCachedUids.map(uid => `uid:${uid}:blocked_uids`)
			);
			return unCachedUids.map((uid, index) => unCachedData[index]);
		});
		return isArray ? cachedData : cachedData[0];
	};

	User.blocks.add = async function (targetUid, uid) {
		await User.blocks.applyChecks('block', targetUid, uid);
		const now = Date.now();
		await db.sortedSetAddBulk([
			[`uid:${uid}:blocked_uids`, now, targetUid],
			[`uid:${targetUid}:blocker_uids`, now, uid],
		]);
		await User.incrementUserFieldBy(uid, 'blocksCount', 1);
		User.blocks._cache.del(String(uid));
		plugins.hooks.fire('action:user.blocks.add', { uid: uid, targetUid: targetUid });
	};

	User.blocks.remove = async function (targetUid, uid) {
		await User.blocks.applyChecks('unblock', targetUid, uid);
		await db.sortedSetRemoveBulk([
			[`uid:${uid}:blocked_uids`, targetUid],
			[`uid:${targetUid}:blocker_uids`, uid],
		]);
		await User.decrementUserFieldBy(uid, 'blocksCount', 1);
		User.blocks._cache.del(String(uid));
		plugins.hooks.fire('action:user.blocks.remove', { uid: uid, targetUid: targetUid });
	};

	User.blocks.applyChecks = async function (type, targetUid, uid) {
		await User.blocks.can(uid, uid, targetUid);
		const isBlock = type === 'block';
		const is = await User.blocks.is(targetUid, uid);
		if (is === isBlock) {
			throw new Error(`[[error:already-${isBlock ? 'blocked' : 'unblocked'}]]`);
		}
	};

	User.blocks.filterUids = async function (targetUid, uids) {
		const isBlocked = await User.blocks.is(targetUid, uids);
		return uids.filter((uid, index) => !isBlocked[index]);
	};

	User.blocks.filter = async function (uid, property, set) {
		// Given whatever is passed in, iterates through it, and removes entries made by blocked uids
		// property is optional
		if (Array.isArray(property) && typeof set === 'undefined') {
			set = property;
			property = 'uid';
		}

		if (!Array.isArray(set) || !set.length) {
			return set;
		}

		const isPlain = typeof set[0] !== 'object';
		const blocked_uids = await User.blocks.list(uid);
		const blockedSet = new Set(blocked_uids);

		set = set.filter((item) => {
			const uid = isPlain ? item : (item && item[property]);
			return !blockedSet.has(String(uid));
		});
		const data = await plugins.hooks.fire('filter:user.blocks.filter', {
			set, property, uid, blockedSet,
		});

		return data.set;
	};
};