Skip to content

Node.js based forum software built for the modern web

4.4 KB
Raw Blame
'use strict';

const _ = require('lodash');

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

module.exports = function (Messaging) {
	Messaging.sendMessage = async (data) => {
		await Messaging.checkContent(data.content, utils.isNumber(data.uid));
		const inRoom = await Messaging.isUserInRoom(data.uid, data.roomId);
		if (!inRoom) {
			throw new Error('[[error:not-allowed]]');
		}

		return await Messaging.addMessage(data);
	};

	Messaging.checkContent = async (content, local = true) => {
		if (!content) {
			throw new Error('[[error:invalid-chat-message]]');
		}

		const maximum = meta.config[local ? 'maximumChatMessageLength' : 'maximumRemoteChatMessageLength'];
		content = String(content).trim();
		let { length } = content;
		({ content, length } = await plugins.hooks.fire('filter:messaging.checkContent', { content, length }));
		if (!content) {
			throw new Error('[[error:invalid-chat-message]]');
		}
		if (length > maximum) {
			throw new Error(`[[error:chat-message-too-long, ${maximum}]]`);
		}
	};

	Messaging.addMessage = async (data) => {
		const { uid, roomId } = data;
		const roomData = await Messaging.getRoomData(roomId);
		if (!roomData) {
			throw new Error('[[error:no-room]]');
		}
		if (data.toMid) {
			if (!await Messaging.messageExists(data.toMid)) {
				throw new Error('[[error:invalid-mid]]');
			}
			if (!await Messaging.canViewMessage(data.toMid, roomId, uid)) {
				throw new Error('[[error:no-privileges]]');
			}
			const system = await Messaging.getMessageField(data.toMid, 'system');
			if (system) {
				throw new Error('[[error:invalid-mid]]');
			}
		}
		const mid = data.mid || await db.incrObjectField('global', 'nextMid');
		const timestamp = data.timestamp || Date.now();
		let message = {
			mid: mid,
			content: String(data.content),
			timestamp: timestamp,
			fromuid: uid,
			roomId: roomId,
		};
		if (data.toMid) {
			message.toMid = data.toMid;
		}
		if (data.system && data.type) {
			message.system = data.system;
			message.type = data.type;
		}

		if (data.ip && meta.config.logIPs) {
			message.ip = data.ip;
		}

		message = await plugins.hooks.fire('filter:messaging.save', message);
		await db.setObject(`message:${mid}`, message);
		const isNewSet = await Messaging.isNewSet(uid, roomId, timestamp);

		const tasks = [
			Messaging.addMessageToRoom(roomId, mid, timestamp),
			Messaging.markRead(uid, roomId),
			db.sortedSetAdd('messages:mid', timestamp, mid),
			db.incrObjectField('global', 'messageCount'),
		];
		if (data.toMid) {
			tasks.push(db.sortedSetAdd(`mid:${data.toMid}:replies`, timestamp, mid));
		}
		if (roomData.public) {
			tasks.push(
				db.sortedSetAdd('chat:rooms:public:lastpost', timestamp, roomId)
			);
		} else {
			let uids = await Messaging.getUidsInRoom(roomId, 0, -1);
			uids = await user.blocks.filterUids(uid, uids);
			tasks.push(
				Messaging.addRoomToUsers(roomId, uids, timestamp),
				Messaging.markUnread(uids.filter(uid => uid !== String(data.uid)), roomId),
			);
		}
		await Promise.all(tasks);

		const messages = await Messaging.getMessagesData([mid], uid, roomId, true);
		if (!messages || !messages[0]) {
			return null;
		}

		messages[0].newSet = isNewSet;
		plugins.hooks.fire('action:messaging.save', { message: message, data: data });
		return messages[0];
	};

	Messaging.addSystemMessage = async (type, uid, roomId, txArgs = []) => {
		// content is actually the type of system message
		// 'user-join', 'user-leave', 'room-rename', etc.
		const displayname = await user.getNotificationDisplayname(uid);
		const now = Date.now();
		txArgs = [displayname, new Date(now).toISOString(), ...txArgs];
		const message = await Messaging.addMessage({
			type: type,
			content: tx.compile(`modules:chat.system.${type}`, ...txArgs),
			uid: uid,
			roomId: roomId,
			system: 1,
			timestamp: now,
		});
		Messaging.notifyUsersInRoom(uid, roomId, message);
	};

	Messaging.addRoomToUsers = async (roomId, uids, timestamp) => {
		if (!uids.length) {
			return;
		}
		const keys = _.uniq(uids).map(uid => `uid:${uid}:chat:rooms`);
		await db.sortedSetsAdd(keys, timestamp, roomId);
	};

	Messaging.addMessageToRoom = async (roomId, mid, timestamp) => {
		await db.sortedSetAdd(`chat:room:${roomId}:mids`, timestamp, mid);
		await db.incrObjectField(`chat:room:${roomId}`, 'messageCount');
	};
};