Skip to content

Node.js based forum software built for the modern web

4.7 KB
Raw Blame
'use strict';

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

const intFields = [
	'cid', 'parentCid', 'disabled', 'isSection', 'order',
	'topic_count', 'post_count', 'numRecentReplies',
	'minTags', 'maxTags', 'postQueue', 'subCategoriesPerPage',
];

const worldCategory = {
	cid: -1,
	name: '[[category:uncategorized]]',
	description: '[[category:uncategorized.description]]',
	descriptionParsed: '[[category:uncategorized.description]]',
	icon: 'fa-globe',
	imageClass: 'cover',
	bgColor: '#eee',
	color: '#333',
	slug: '../world',
	parentCid: 0,
	disabled: 0,
	handle: 'world',
	link: '',
	class: '',
};

module.exports = function (Categories) {
	Categories.getCategoriesFields = async function (cids, fields) {
		if (!Array.isArray(cids) || !cids.length) {
			return [];
		}

		cids = cids.map(cid => (utils.isNumber(cid) ? parseInt(cid, 10) : cid));
		const keys = cids.map(cid => (utils.isNumber(cid) ? `category:${cid}` : `categoryRemote:${cid}`));
		const categories = await db.getObjects(keys, fields);

		// Handle cid -1
		if (cids.includes(-1)) {
			let subset = null;
			if (fields && fields.length) {
				subset = fields.reduce((category, field) => {
					category[field] = worldCategory[field] || undefined;
					return category;
				}, {});
			}
			categories.splice(cids.indexOf(-1), 1, subset || { ...worldCategory });
		}

		const result = await plugins.hooks.fire('filter:category.getFields', {
			cids: cids,
			categories: categories,
			fields: fields,
			keys: keys,
		});
		await modifyCategories(result.categories, result.fields);
		return result.categories;
	};

	Categories.getCategoryData = async function (cid) {
		const categories = await Categories.getCategoriesFields([cid], []);
		return categories && categories.length ? categories[0] : null;
	};

	Categories.getCategoriesData = async function (cids) {
		return await Categories.getCategoriesFields(cids, []);
	};

	Categories.getCategoryField = async function (cid, field) {
		const category = await Categories.getCategoryFields(cid, [field]);
		return category && category.hasOwnProperty(field) ? category[field] : null;
	};

	Categories.getCategoryFields = async function (cid, fields) {
		const categories = await Categories.getCategoriesFields([cid], fields);
		return categories ? categories[0] : null;
	};

	Categories.getAllCategoryFields = async function (fields) {
		const cids = await Categories.getAllCidsFromSet('categories:cid');
		return await Categories.getCategoriesFields(cids, fields);
	};

	Categories.setCategoryField = async function (cid, field, value) {
		await db.setObjectField(
			utils.isNumber(cid) ? `category:${cid}` : `categoryRemote:${cid}`,
			field, value
		);
	};

	Categories.setCategoryFields = async function (cid, fields) {
		await db.setObject(
			utils.isNumber(cid) ? `category:${cid}` : `categoryRemote:${cid}`,
			fields
		);
	};

	Categories.incrementCategoryFieldBy = async function (cid, field, value) {
		await db.incrObjectFieldBy(utils.isNumber(cid) ? `category:${cid}` : `categoryRemote:${cid}`, field, value);
	};
};

function defaultIntField(category, hasField, fieldName, defaultField) {
	if (hasField(fieldName)) {
		const useDefault = !category.hasOwnProperty(fieldName) ||
			category[fieldName] === null ||
			category[fieldName] === '' ||
			!utils.isNumber(category[fieldName]);

		category[fieldName] = useDefault ? meta.config[defaultField] : category[fieldName];
	}
}

async function modifyCategories(categories, fields) {
	if (!categories || !categories.length) {
		return;
	}
	const hasField = utils.createFieldChecker(fields);

	await Promise.all(categories.map(async (category) => {
		if (!category) return;
		defaultIntField(category, hasField, 'minTags', 'minimumTagsPerTopic');
		defaultIntField(category, hasField, 'maxTags', 'maximumTagsPerTopic');
		defaultIntField(category, hasField, 'postQueue', 'postQueue');

		db.parseIntFields(category, intFields, fields);

		if (hasField('icon')) {
			category.icon = category.icon || 'hidden';
			if (category.icon === 'fa-none') {
				category.icon = 'fa-nbb-none';
			}
		}

		if (hasField('post_count')) {
			category.totalPostCount = category.post_count;
		}

		if (hasField('topic_count')) {
			category.totalTopicCount = category.topic_count;
		}

		if (hasField('nickname')) {
			category.nickname = category.nickname || '';
		}

		if (hasField('name')) {
			category.name = category.nickname || category.name;
		}

		if (hasField('url')) {
			category.url = utils.isSafeHref(category.url) ? category.url : '';
		}

		if (hasField('description') && category.cid !== -1) {
			category.descriptionParsed = await plugins.hooks.fire('filter:parse.raw', category.description || '');
		}
	}));
}