Skip to content

Node.js based forum software built for the modern web

7.9 KB
Raw Blame
'use strict';

const db = require('../database');
const topics = require('../topics');
const plugins = require('../plugins');
const meta = require('../meta');
const privileges = require('../privileges');
const user = require('../user');
const utils = require('../utils');

module.exports = function (Categories) {
	Categories.getCategoryTopics = async function (data) {
		let results = await plugins.hooks.fire('filter:category.topics.prepare', data);
		const tids = await Categories.getTopicIds(results);
		let topicsData = await topics.getTopicsByTids(tids, data.uid);
		topicsData = await user.blocks.filter(data.uid, topicsData);

		if (!topicsData.length) {
			return { topics: [], uid: data.uid };
		}
		topics.calculateTopicIndices(topicsData, data.start);

		results = await plugins.hooks.fire('filter:category.topics.get', { cid: data.cid, topics: topicsData, uid: data.uid });
		return { topics: results.topics, nextStart: data.stop + 1 };
	};

	Categories.getTopicIds = async function (data) {
		const [pinnedTids, set] = await Promise.all([
			Categories.getPinnedTids({ ...data, start: 0, stop: -1 }),
			Categories.buildTopicsSortedSet(data),
		]);

		const totalPinnedCount = pinnedTids.length;
		const pinnedTidsOnPage = pinnedTids.slice(data.start, data.stop !== -1 ? data.stop + 1 : undefined);
		const pinnedCountOnPage = pinnedTidsOnPage.length;
		const topicsPerPage = data.stop - data.start + 1;
		const normalTidsToGet = Math.max(0, topicsPerPage - pinnedCountOnPage);

		if (!normalTidsToGet && data.stop !== -1) {
			return pinnedTidsOnPage;
		}

		if (plugins.hooks.hasListeners('filter:categories.getTopicIds')) {
			const result = await plugins.hooks.fire('filter:categories.getTopicIds', {
				tids: [],
				data: data,
				pinnedTids: pinnedTidsOnPage,
				allPinnedTids: pinnedTids,
				totalPinnedCount: totalPinnedCount,
				normalTidsToGet: normalTidsToGet,
			});
			return result && result.tids;
		}

		let { start } = data;
		if (start > 0 && totalPinnedCount) {
			start -= totalPinnedCount - pinnedCountOnPage;
		}

		const stop = data.stop === -1 ? data.stop : start + normalTidsToGet - 1;
		let normalTids;
		if (Array.isArray(set)) {
			const weights = set.map((s, index) => (index ? 0 : 1));
			normalTids = await db.getSortedSetRevIntersect({ sets: set, start: start, stop: stop, weights: weights });
		} else {
			normalTids = await db.getSortedSetRevRange(set, start, stop);
		}
		normalTids = normalTids.filter(tid => !pinnedTids.includes(tid));
		return pinnedTidsOnPage.concat(normalTids);
	};

	Categories.getTopicCount = async function (data) {
		if (plugins.hooks.hasListeners('filter:categories.getTopicCount')) {
			const result = await plugins.hooks.fire('filter:categories.getTopicCount', {
				topicCount: data.category.topic_count,
				data: data,
			});
			return result && result.topicCount;
		}
		const set = await Categories.buildTopicsSortedSet(data);
		if (Array.isArray(set)) {
			return await db.sortedSetIntersectCard(set);
		} else if (parseInt(data.cid, 10) === -1 || (data.targetUid && set)) {
			return await db.sortedSetCard(set);
		}
		return data.category.topic_count;
	};

	Categories.buildTopicsSortedSet = async function (data) {
		const { cid, uid } = data;
		const sort = data.sort || (data.settings && data.settings.categoryTopicSort) || meta.config.categoryTopicSort || 'recently_replied';
		const sortToSet = {
			recently_replied: `cid:${cid}:tids`,
			recently_created: `cid:${cid}:tids:create`,
			most_posts: `cid:${cid}:tids:posts`,
			most_votes: `cid:${cid}:tids:votes`,
			most_views: `cid:${cid}:tids:views`,
		};

		const mainSet = sortToSet.hasOwnProperty(sort) ? sortToSet[sort] : `cid:${cid}:tids`;
		const set = new Set([mainSet]);

		if (data.tag) {
			if (Array.isArray(data.tag)) {
				data.tag.forEach((tag) => {
					set.add(`tag:${tag}:topics`);
				});
			} else {
				set.add(`tag:${data.tag}:topics`);
			}
		}

		if (data.targetUid) {
			set.add(`cid:${cid}:uid:${data.targetUid}:tids`);
		}

		if (parseInt(cid, 10) === -1 && uid > 0) {
			set.delete(mainSet);
			set.add(`uid:${uid}:inbox`);
		}
		const setValue = Array.from(set);
		const result = await plugins.hooks.fire('filter:categories.buildTopicsSortedSet', {
			set: set.size > 1 ? setValue : setValue[0],
			data: data,
		});
		return result && result.set;
	};

	Categories.getSortedSetRangeDirection = async function (sort) {
		console.warn('[deprecated] Will be removed in 4.x');
		sort = sort || 'recently_replied';
		const direction = ['newest_to_oldest', 'most_posts', 'most_votes', 'most_views'].includes(sort) ? 'highest-to-lowest' : 'lowest-to-highest';
		const result = await plugins.hooks.fire('filter:categories.getSortedSetRangeDirection', {
			sort: sort,
			direction: direction,
		});
		return result && result.direction;
	};

	Categories.getAllTopicIds = async function (cid, start, stop) {
		return await db.getSortedSetRange([`cid:${cid}:tids:pinned`, `cid:${cid}:tids`], start, stop);
	};

	Categories.getPinnedTids = async function (data) {
		if (plugins.hooks.hasListeners('filter:categories.getPinnedTids')) {
			const result = await plugins.hooks.fire('filter:categories.getPinnedTids', {
				pinnedTids: [],
				data: data,
			});
			return result && result.pinnedTids;
		}
		const [allPinnedTids, canSchedule] = await Promise.all([
			db.getSortedSetRevRange(`cid:${data.cid}:tids:pinned`, data.start, data.stop),
			privileges.categories.can('topics:schedule', data.cid, data.uid),
		]);
		const pinnedTids = canSchedule ? allPinnedTids : await filterScheduledTids(allPinnedTids);

		return await topics.tools.checkPinExpiry(pinnedTids);
	};

	Categories.modifyTopicsByPrivilege = async function (topics, privileges) {
		if (!Array.isArray(topics) || !topics.length || privileges.view_deleted) {
			return;
		}

		topics.forEach((topic) => {
			if (topic && !topic.scheduled && topic.deleted && !topic.isOwner) {
				topic.title = '[[topic:topic-is-deleted]]';
				topic.txTitle = true;
				topic.slug = topic.tid;
				topic.teaser = null;
				topic.noAnchor = true;
				topic.unread = false;
				topic.tags = [];
			}
		});
	};

	Categories.onNewPostMade = async function (cid, pinned, postData) {
		if (!cid || !postData) {
			return;
		}
		const promises = [
			db.sortedSetAdd(`cid:${cid}:pids`, postData.timestamp, postData.pid),
			db.incrObjectField(`${utils.isNumber(cid) ? 'category' : 'categoryRemote'}:${cid}`, 'post_count'),
		];
		if (!pinned) {
			promises.push(db.sortedSetIncrBy(`cid:${cid}:tids:posts`, 1, postData.tid));
		}
		await Promise.all(promises);
		await Categories.updateRecentTidForCid(cid);
	};

	Categories.onTopicsMoved = async (cids) => {
		await Promise.all(cids.map(async (cid) => {
			const [topicCount, postCount] = await db.sortedSetsCard([
				`cid:${cid}:tids:lastposttime`,
				`cid:${cid}:pids`,
			]);
			await Promise.all([
				Categories.setCategoryFields(cid, {
					topic_count: topicCount,
					post_count: postCount,
				}),
				Categories.updateRecentTidForCid(cid),
			]);
		}));
	};

	async function filterScheduledTids(tids) {
		const scores = await db.sortedSetScores('topics:scheduled', tids);
		const now = Date.now();
		return tids.filter((tid, index) => tid && (!scores[index] || scores[index] <= now));
	}

	Categories.sortTidsBySet = async (tids, sort) => {
		let cids = await topics.getTopicsFields(tids, ['cid']);
		cids = cids.map(({ cid }) => cid);

		function getSet(cid, sort) {
			sort = sort || meta.config.categoryTopicSort || 'recently_replied';
			const sortToSet = {
				recently_replied: `cid:${cid}:tids`,
				recently_created: `cid:${cid}:tids:create`,
				most_posts: `cid:${cid}:tids:posts`,
				most_votes: `cid:${cid}:tids:votes`,
				most_views: `cid:${cid}:tids:views`,
			};

			return sortToSet[sort];
		}

		const scores = await Promise.all(tids.map(async (tid, idx) => {
			const cid = cids[idx];
			const orderBy = getSet(cid, sort);
			return await db.sortedSetScore(orderBy, tid);
		}));

		const sorted = tids
			.map((tid, idx) => [tid, scores[idx]])
			.sort(([, a], [, b]) => b - a)
			.map(([tid]) => tid);

		return sorted;
	};
};