NodeBB/src/messaging/index.js

'use strict';

const _ = require('lodash');
const validator = require('validator');
const nconf = require('nconf');
const db = require('../database');
const user = require('../user');
const groups = require('../groups');
const privileges = require('../privileges');
const plugins = require('../plugins');
const meta = require('../meta');
const utils = require('../utils');
const translator = require('../translator');
const cache = require('../cache');

const relative_path = nconf.get('relative_path');

const Messaging = module.exports;

require('./data')(Messaging);
require('./create')(Messaging);
require('./delete')(Messaging);
require('./edit')(Messaging);
require('./rooms')(Messaging);
require('./unread')(Messaging);
require('./notifications')(Messaging);
require('./pins')(Messaging);

Messaging.notificationSettings = Object.create(null);
Messaging.notificationSettings.NONE = 1;
Messaging.notificationSettings.ATMENTION = 2;
Messaging.notificationSettings.ALLMESSAGES = 3;

Messaging.messageExists = async mid => db.exists(`message:${mid}`);

Messaging.getMessages = async (params) => {
	const { callerUid, uid, roomId } = params;
	const isNew = params.isNew || false;
	const start = params.hasOwnProperty('start') ? params.start : 0;
	const stop = parseInt(start, 10) + ((params.count || 50) - 1);

	const ok = await canGet('filter:messaging.canGetMessages', callerUid, uid);
	if (!ok) {
		return;
	}
	const [mids, messageCount] = await Promise.all([
		getMessageIds(roomId, uid, start, stop),
		db.getObjectField(`chat:room:${roomId}`, 'messageCount'),
	]);
	if (!mids.length) {
		return [];
	}
	const count = parseInt(messageCount, 10) || 0;
	const indices = {};
	mids.forEach((mid, index) => {
		indices[mid] = count - start - index - 1;
	});
	mids.reverse();

	const messageData = await Messaging.getMessagesData(mids, uid, roomId, isNew);
	messageData.forEach((msg) => {
		msg.index = indices[msg.messageId.toString()];
	});

	return messageData;
};

async function getMessageIds(roomId, uid, start, stop) {
	const isPublic = await db.getObjectField(`chat:room:${roomId}`, 'public');
	if (parseInt(isPublic, 10) === 1) {
		return await db.getSortedSetRevRange(
			`chat:room:${roomId}:mids`, start, stop,
		);
	}
	const userjoinTimestamp = await db.sortedSetScore(`chat:room:${roomId}:uids`, uid);
	return await db.getSortedSetRevRangeByScore(
		`chat:room:${roomId}:mids`, start, stop - start + 1, '+inf', userjoinTimestamp
	);
}

async function canGet(hook, callerUid, uid) {
	const data = await plugins.hooks.fire(hook, {
		callerUid: callerUid,
		uid: uid,
		canGet: parseInt(callerUid, 10) === parseInt(uid, 10),
	});

	return data ? data.canGet : false;
}

Messaging.parse = async (message, fromuid, uid, roomId, isNew) => {
	const parsed = await plugins.hooks.fire('filter:parse.raw', String(message || ''));
	let messageData = {
		message: message,
		parsed: parsed,
		fromuid: fromuid,
		uid: uid,
		roomId: roomId,
		isNew: isNew,
		parsedMessage: parsed,
	};

	messageData = await plugins.hooks.fire('filter:messaging.parse', messageData);
	return messageData ? messageData.parsedMessage : '';
};

Messaging.isNewSet = async (uid, roomId, timestamp) => {
	const setKey = `chat:room:${roomId}:mids`;
	const messages = await db.getSortedSetRevRangeWithScores(setKey, 0, 0);
	if (messages && messages.length) {
		return parseInt(timestamp, 10) > parseInt(messages[0].score, 10) + Messaging.newMessageCutoff;
	}
	return true;
};

Messaging.getPublicRoomIdsFromSet = async function (set) {
	const cacheKey = `${set}:all`;
	let allRoomIds = cache.get(cacheKey);
	if (allRoomIds === undefined) {
		allRoomIds = await db.getSortedSetRange(set, 0, -1);
		cache.set(cacheKey, allRoomIds);
	}
	return allRoomIds.slice();
};

Messaging.getPublicRooms = async (callerUid, uid) => {
	const ok = await canGet('filter:messaging.canGetPublicChats', callerUid, uid);
	if (!ok) {
		return null;
	}

	const allRoomIds = await Messaging.getPublicRoomIdsFromSet('chat:rooms:public:order');
	const allRoomData = await Messaging.getRoomsData(allRoomIds);
	const isAdmin = await privileges.users.isAdministrator(callerUid);
	const checks = await Promise.all(
		allRoomData.map(
			room => room && (
				!Array.isArray(room.groups) ||
				!room.groups.length ||
				isAdmin ||
				groups.isMemberOfAny(uid, room && room.groups)
			)
		)
	);

	const roomData = allRoomData.filter((room, idx) => room && checks[idx]);
	const roomIds = roomData.map(r => r.roomId);
	const userReadTimestamps = await db.getObjectFields(
		`uid:${uid}:chat:rooms:read`,
		roomIds,
	);

	const maxUnread = 50;
	const unreadCounts = await Promise.all(roomIds.map(async (roomId) => {
		const cutoff = userReadTimestamps[roomId] || '-inf';
		const unreadMids = await db.getSortedSetRangeByScore(
			`chat:room:${roomId}:mids`, 0, maxUnread + 1, cutoff, '+inf'
		);
		return unreadMids.length;
	}));

	roomData.forEach((r, idx) => {
		const count = unreadCounts[idx];
		r.unreadCountText = count > maxUnread ? `${maxUnread}+` : String(count);
		r.unreadCount = count;
		r.unread = count > 0;
		r.icon = Messaging.getRoomIcon(r);
	});

	return roomData;
};

Messaging.getRecentChats = async (callerUid, uid, start, stop) => {
	const ok = await canGet('filter:messaging.canGetRecentChats', callerUid, uid);
	if (!ok) {
		throw new Error('[[error:no-privileges]]');
	}

	const roomIds = await db.getSortedSetRevRange(`uid:${uid}:chat:rooms`, start, stop);

	async function getUsers(roomIds) {
		const arrayOfUids = await Promise.all(
			roomIds.map(roomId => Messaging.getUidsInRoom(roomId, 0, 9))
		);
		const uniqUids = _.uniq(_.flatten(arrayOfUids)).filter(
			_uid => _uid && parseInt(_uid, 10) !== parseInt(uid, 10)
		);
		const uidToUser = _.zipObject(
			uniqUids,
			await user.getUsersFields(uniqUids, [
				'uid', 'username', 'userslug', 'picture', 'status', 'lastonline',
			])
		);
		return arrayOfUids.map(uids => uids.map(uid => uidToUser[uid]));
	}

	const results = await utils.promiseParallel({
		roomData: Messaging.getRoomsData(roomIds),
		unread: db.isSortedSetMembers(`uid:${uid}:chat:rooms:unread`, roomIds),
		users: getUsers(roomIds),
		teasers: Messaging.getTeasers(uid, roomIds),
		settings: user.getSettings(uid),
	});

	await Promise.all(results.roomData.map(async (room, index) => {
		if (room) {
			room.users = results.users[index];
			room.groupChat = room.users.length > 2;
			room.unread = results.unread[index];
			room.teaser = results.teasers[index];

			room.users.forEach((userData) => {
				if (userData && parseInt(userData.uid, 10)) {
					userData.status = user.getStatus(userData);
				}
			});
			room.users = room.users.filter(user => user && parseInt(user.uid, 10));
			room.lastUser = room.users[0];
			room.usernames = Messaging.generateUsernames(room, uid);
			room.chatWithMessage = await Messaging.generateChatWithMessage(room, uid, results.settings.userLang);
		}
	}));

	results.roomData = results.roomData.filter(Boolean);
	const ref = { rooms: results.roomData, nextStart: stop + 1 };
	return await plugins.hooks.fire('filter:messaging.getRecentChats', {
		rooms: ref.rooms,
		nextStart: ref.nextStart,
		uid: uid,
		callerUid: callerUid,
	});
};

Messaging.generateUsernames = function (room, excludeUid) {
	const users = room.users.filter(u => u && parseInt(u.uid, 10) !== excludeUid);
	const usernames = users.map(u => u.username);
	if (users.length > 3) {
		return translator.compile(
			'modules:chat.usernames-and-x-others',
			usernames.slice(0, 2).join(', '),
			room.userCount - 2
		);
	}
	return usernames.join(', ');
};

Messaging.generateChatWithMessage = async function (room, callerUid, userLang) {
	const users = room.users.filter(u => u && parseInt(u.uid, 10) !== callerUid);
	const usernames = users.map(u => `<a href="${relative_path}/uid/${u.uid}">${u.username}</a>`);
	let compiled = '';
	if (!users.length) {
		return '[[modules:chat.no-users-in-room]]';
	}
	if (users.length > 3) {
		compiled = translator.compile(
			'modules:chat.chat-with-usernames-and-x-others',
			usernames.slice(0, 2).join(', '),
			room.userCount - 2
		);
	} else {
		compiled = translator.compile(
			'modules:chat.chat-with-usernames',
			usernames.join(', '),
		);
	}
	return utils.decodeHTMLEntities(await translator.translate(compiled, userLang));
};

Messaging.getTeaser = async (uid, roomId) => {
	const teasers = await Messaging.getTeasers(uid, [roomId]);
	return teasers[0];
};

Messaging.getTeasers = async (uid, roomIds) => {
	const mids = await Promise.all(
		roomIds.map(roomId => Messaging.getLatestUndeletedMessage(uid, roomId))
	);
	const [teasers, blockedUids] = await Promise.all([
		Messaging.getMessagesFields(mids, ['fromuid', 'content', 'timestamp']),
		user.blocks.list(uid),
	]);
	const uids = _.uniq(
		teasers.map(t => t && t.fromuid).filter(uid => uid && !blockedUids.includes(uid))
	);

	const userMap = _.zipObject(
		uids,
		await user.getUsersFields(uids, [
			'uid', 'username', 'userslug', 'picture', 'status', 'lastonline',
		])
	);

	return await Promise.all(roomIds.map(async (roomId, idx) => {
		const teaser = teasers[idx];
		if (!teaser || !teaser.fromuid) {
			return null;
		}
		if (userMap[teaser.fromuid]) {
			teaser.user = userMap[teaser.fromuid];
		}
		teaser.content = validator.escape(
			String(utils.stripHTMLTags(utils.decodeHTMLEntities(teaser.content)))
		);
		teaser.roomId = roomId;
		const payload = await plugins.hooks.fire('filter:messaging.getTeaser', { teaser: teaser });
		return payload.teaser;
	}));
};

Messaging.getLatestUndeletedMessage = async (uid, roomId) => {
	let done = false;
	let latestMid = null;
	let index = 0;
	let mids;

	while (!done) {
		/* eslint-disable no-await-in-loop */
		mids = await getMessageIds(roomId, uid, index, index);
		if (mids.length) {
			const states = await Messaging.getMessageFields(mids[0], ['deleted', 'system']);
			done = !states.deleted && !states.system;
			if (done) {
				latestMid = mids[0];
			}
			index += 1;
		} else {
			done = true;
		}
	}

	return latestMid;
};

Messaging.canMessageUser = async (uid, toUid) => {
	if (meta.config.disableChat || uid <= 0) {
		throw new Error('[[error:chat-disabled]]');
	}

	if (parseInt(uid, 10) === parseInt(toUid, 10)) {
		throw new Error('[[error:cant-chat-with-yourself]]');
	}
	const [exists, isTargetPrivileged, canChat, canChatWithPrivileged] = await Promise.all([
		user.exists(toUid),
		user.isPrivileged(toUid),
		privileges.global.can('chat', uid),
		privileges.global.can('chat:privileged', uid),
		checkReputation(uid),
	]);

	if (!exists) {
		throw new Error('[[error:no-user]]');
	}

	if (!canChat && !(canChatWithPrivileged && isTargetPrivileged)) {
		throw new Error('[[error:no-privileges]]');
	}

	const [settings, isAdmin, isModerator, isFollowing, isBlocked] = await Promise.all([
		user.getSettings(toUid),
		user.isAdministrator(uid),
		user.isModeratorOfAnyCategory(uid),
		user.isFollowing(toUid, uid),
		user.blocks.is(uid, toUid),
	]);

	if (isBlocked || (settings.restrictChat && !isAdmin && !isModerator && !isFollowing)) {
		throw new Error('[[error:chat-restricted]]');
	}

	await plugins.hooks.fire('static:messaging.canMessageUser', {
		uid: uid,
		toUid: toUid,
	});
};

Messaging.canMessageRoom = async (uid, roomId) => {
	if (meta.config.disableChat || uid <= 0) {
		throw new Error('[[error:chat-disabled]]');
	}

	const [roomData, inRoom, canChat] = await Promise.all([
		Messaging.getRoomData(roomId),
		Messaging.isUserInRoom(uid, roomId),
		privileges.global.can(['chat', 'chat:privileged'], uid),
		checkReputation(uid),
		user.checkMuted(uid),
	]);
	if (!roomData) {
		throw new Error('[[error:no-room]]');
	}

	if (!inRoom) {
		throw new Error('[[error:not-in-room]]');
	}

	if (!canChat.includes(true)) {
		throw new Error('[[error:no-privileges]]');
	}

	await plugins.hooks.fire('static:messaging.canMessageRoom', {
		uid: uid,
		roomId: roomId,
	});
};

async function checkReputation(uid) {
	if (meta.config['reputation:disabled']) {
		return;
	}
	const [reputation, isPrivileged] = await Promise.all([
		user.getUserField(uid, 'reputation'),
		user.isPrivileged(uid),
	]);
	if (!isPrivileged && meta.config['min:rep:chat'] > reputation) {
		throw new Error(`[[error:not-enough-reputation-to-chat, ${meta.config['min:rep:chat']}]]`);
	}
}

Messaging.hasPrivateChat = async (uid, withUid) => {
	if (parseInt(uid, 10) === parseInt(withUid, 10) ||
		parseInt(uid, 10) <= 0 || parseInt(withUid, 10) <= 0) {
		return 0;
	}

	const results = await utils.promiseParallel({
		myRooms: db.getSortedSetRevRange(`uid:${uid}:chat:rooms`, 0, -1),
		theirRooms: db.getSortedSetRevRange(`uid:${withUid}:chat:rooms`, 0, -1),
	});
	const roomIds = results.myRooms.filter(roomId => roomId && results.theirRooms.includes(roomId));

	if (!roomIds.length) {
		return 0;
	}

	let index = 0;
	let roomId = 0;
	while (index < roomIds.length && !roomId) {
		/* eslint-disable no-await-in-loop */
		const count = await Messaging.getUserCountInRoom(roomIds[index]);
		if (count === 2) {
			roomId = roomIds[index];
		} else {
			index += 1;
		}
	}

	return roomId;
};

Messaging.canViewMessage = async (mids, roomId, uid) => {
	let single = false;
	if (!Array.isArray(mids) && isFinite(mids)) {
		mids = [mids];
		single = true;
	}
	const isPublic = parseInt(await db.getObjectField(`chat:room:${roomId}`, 'public'), 10) === 1;
	const [midTimestamps, userTimestamp] = await Promise.all([
		db.sortedSetScores(`chat:room:${roomId}:mids`, mids),
		db.sortedSetScore(`chat:room:${roomId}:uids`, uid),
	]);

	const canView = midTimestamps.map(
		midTimestamp => !!(midTimestamp && userTimestamp && (isPublic || userTimestamp <= midTimestamp))
	);

	return single ? canView.pop() : canView;
};

require('../promisify')(Messaging);