[NEW] Direct message between multiple users

app/apps/server/bridges/rooms.js

@@ -1,7 +1,7 @@
 import { Meteor } from 'meteor/meteor';
 import { RoomType } from '@rocket.chat/apps-engine/definition/rooms';
 
-import { Rooms, Subscriptions, Users } from '../../../models';
+import { Rooms, Subscriptions, Users } from '../../../models/server';
 import { addUserToRoom } from '../../../lib/server/functions/addUserToRoom';
 
 export class AppRoomBridge {
@@ -38,8 +38,7 @@ export class AppRoomBridge {
 			delete extraData.customFields;
 			let info;
 			if (room.type === RoomType.DIRECT_MESSAGE) {
-				members.splice(members.indexOf(room.creator.username), 1);
-				info = Meteor.call(method, members[0]);
+				info = Meteor.call(method, ...members);
 			} else {
 				info = Meteor.call(method, rcRoom.name, members, rcRoom.ro, rcRoom.customFields, extraData);
 			}

app/apps/server/converters/rooms.js

@@ -79,6 +79,7 @@ export class AppRoomsConverter {
 			servedBy,
 			closedBy,
 			members: room.members,
+			uids: room.uids,
 			default: typeof room.isDefault === 'undefined' ? false : room.isDefault,
 			ro: typeof room.isReadOnly === 'undefined' ? false : room.isReadOnly,
 			sysMes: typeof room.displaySystemMessages === 'undefined' ? true : room.displaySystemMessages,
@@ -105,6 +106,7 @@ export class AppRoomsConverter {
 			displayName: 'fname',
 			slugifiedName: 'name',
 			members: 'members',
+			uids: 'uids',
 			messageCount: 'msgs',
 			createdAt: 'ts',
 			updatedAt: '_updatedAt',

app/federation/server/hooks/afterCreateDirectRoom.js

@@ -29,36 +29,19 @@ async function afterCreateDirectRoom(room, extras) {
 		// Ensure a genesis event for this room
 		const genesisEvent = await FederationRoomEvents.createGenesisEvent(getFederationDomain(), normalizedRoom);
 
-		//
-		// Source User
-		//
-
-		// Add the source user to the room
-		const sourceUser = extras.from;
-		const normalizedSourceUser = normalizers.normalizeUser(sourceUser);
-
-		const sourceSubscription = Subscriptions.findOne({ rid: normalizedRoom._id, 'u._id': normalizedSourceUser._id });
-		const normalizedSourceSubscription = normalizers.normalizeSubscription(sourceSubscription);
-
-		// Build the source user event
-		const sourceUserEvent = await FederationRoomEvents.createAddUserEvent(getFederationDomain(), normalizedRoom._id, normalizedSourceUser, normalizedSourceSubscription);
-
-		//
-		// Target User
-		//
 
-		// Add the target user to the room
-		const targetUser = extras.to;
-		const normalizedTargetUser = normalizers.normalizeUser(targetUser);
+		const events = await Promise.all(extras.members.map((member) => {
+			const normalizedMember = normalizers.normalizeUser(member);
 
-		const targetSubscription = Subscriptions.findOne({ rid: normalizedRoom._id, 'u._id': normalizedTargetUser._id });
-		const normalizedTargetSubscription = normalizers.normalizeSubscription(targetSubscription);
+			const sourceSubscription = Subscriptions.findOne({ rid: normalizedRoom._id, 'u._id': normalizedMember._id });
+			const normalizedSourceSubscription = normalizers.normalizeSubscription(sourceSubscription);
 
-		// Dispatch the target user event
-		const targetUserEvent = await FederationRoomEvents.createAddUserEvent(getFederationDomain(), normalizedRoom._id, normalizedTargetUser, normalizedTargetSubscription);
+			// Build the user event
+			return FederationRoomEvents.createAddUserEvent(getFederationDomain(), normalizedRoom._id, normalizedMember, normalizedSourceSubscription);
+		}));
 
 		// Dispatch the events
-		dispatchEvents(normalizedRoom.federation.domains, [genesisEvent, sourceUserEvent, targetUserEvent]);
+		dispatchEvents(normalizedRoom.federation.domains, [genesisEvent, ...events]);
 	} catch (err) {
 		await deleteRoom(room._id);
 

app/integrations/server/lib/triggerHandler.js

@@ -496,28 +496,35 @@ integrations.triggerHandler = new class RocketChatIntegrationHandler {
 		if (room) {
 			switch (room.t) {
 				case 'd':
-					const id = room._id.replace(message.u._id, '');
-					const username = _.without(room.usernames, message.u.username)[0];
-
-					if (this.triggers[`@${ id }`]) {
-						for (const trigger of Object.values(this.triggers[`@${ id }`])) {
-							triggersToExecute.push(trigger);
-						}
-					}
-
 					if (this.triggers.all_direct_messages) {
 						for (const trigger of Object.values(this.triggers.all_direct_messages)) {
 							triggersToExecute.push(trigger);
 						}
 					}
 
-					if (id !== username && this.triggers[`@${ username }`]) {
-						for (const trigger of Object.values(this.triggers[`@${ username }`])) {
-							triggersToExecute.push(trigger);
-						}
+					if (!room.uids) {
+						return;
 					}
-					break;
 
+					room.uids.forEach((uid) => {
+						if (this.triggers[`@${ uid }`]) {
+							for (const trigger of Object.values(this.triggers[`@${ uid }`])) {
+								triggersToExecute.push(trigger);
+							}
+						}
+					});
+
+					room.usernames.forEach((username) => {
+						if (room.uids.includes(username) || username === message.u.username) {
+							return;
+						}
+						if (this.triggers[`@${ username }`]) {
+							for (const trigger of Object.values(this.triggers[`@${ username }`])) {
+								triggersToExecute.push(trigger);
+							}
+						}
+					});
+					break;
 				case 'c':
 					if (this.triggers.all_public_channels) {
 						for (const trigger of Object.values(this.triggers.all_public_channels)) {

app/lib/client/defaultTabBars.js

@@ -3,6 +3,7 @@ import { Session } from 'meteor/session';
 import { TabBar } from '../../ui-utils';
 import { Rooms } from '../../models';
 import { hasAllPermission } from '../../authorization';
+import { roomTypes } from '../../utils/client';
 
 TabBar.addButton({
 	groups: ['channel', 'group', 'direct'],
@@ -20,6 +21,31 @@ TabBar.addButton({
 	icon: 'user',
 	template: 'membersList',
 	order: 2,
+	condition() {
+		const rid = Session.get('openedRoom');
+		const room = Rooms.findOne({
+			_id: rid,
+		});
+
+		return room && !roomTypes.getConfig(room.t).isGroupChat(room);
+	},
+});
+
+TabBar.addButton({
+	groups: ['direct'],
+	id: 'user-info-group',
+	i18nTitle: 'Members_List',
+	icon: 'team',
+	template: 'membersList',
+	order: 2,
+	condition() {
+		const rid = Session.get('openedRoom');
+		const room = Rooms.findOne({
+			_id: rid,
+		});
+
+		return room && roomTypes.getConfig(room.t).isGroupChat(room);
+	},
 });
 
 TabBar.addButton({

app/lib/lib/roomTypes/direct.js

@@ -7,21 +7,22 @@ import { getUserPreference, RoomTypeConfig, RoomTypeRouteConfig, RoomSettingsEnu
 import { hasPermission, hasAtLeastOnePermission } from '../../../authorization';
 import { settings } from '../../../settings';
 import { getUserAvatarURL } from '../../../utils/lib/getUserAvatarURL';
+import { getAvatarURL } from '../../../utils/lib/getAvatarURL';
 
 export class DirectMessageRoomRoute extends RoomTypeRouteConfig {
 	constructor() {
 		super({
 			name: 'direct',
-			path: '/direct/:username',
+			path: '/direct/:rid',
 		});
 	}
 
 	action(params) {
-		return openRoom('d', params.username);
+		return openRoom('d', params.rid);
 	}
 
 	link(sub) {
-		return { username: sub.name };
+		return { rid: sub.rid || sub.name };
 	}
 }
 
@@ -36,14 +37,25 @@ export class DirectMessageRoomType extends RoomTypeConfig {
 		});
 	}
 
+
+	getIcon(roomData) {
+		if (roomData.uids && roomData.uids.length > 2) {
+			return 'team';
+		}
+		return this.icon;
+	}
+
 	findRoom(identifier) {
 		if (!hasPermission('view-d-room')) {
 			return null;
 		}
 
 		const query = {
 			t: 'd',
-			name: identifier,
+			$or: [
+				{ name: identifier },
+				{ rid: identifier },
+			],
 		};
 
 		const subscription = Subscriptions.findOne(query);
@@ -161,11 +173,19 @@ export class DirectMessageRoomType extends RoomTypeConfig {
 		return { title, text };
 	}
 
-	getAvatarPath(roomData) {
-		return getUserAvatarURL(roomData.name || this.roomName(roomData));
+	getAvatarPath(roomData, subData) {
+		if (roomData && roomData.uids && roomData.uids.length > 2) {
+			return getAvatarURL({ username: roomData.uids.length + roomData.usernames.join() });
+		}
+		const sub = subData || Subscriptions.findOne({ rid: roomData._id }, { fields: { name: 1 } });
+		return getUserAvatarURL(sub.name || this.roomName(roomData));
 	}
 
 	includeInDashboard() {
 		return true;
 	}
+
+	isGroupChat(room) {
+		return room.usernames && room.usernames.length > 2;
+	}
 }

app/lib/server/functions/createDirectRoom.js

@@ -1,83 +1,87 @@
 import { Rooms, Subscriptions } from '../../../models/server';
+import { settings } from '../../../settings/lib/settings';
 import { getDefaultSubscriptionPref } from '../../../utils/server';
 import { callbacks } from '../../../callbacks/server';
 
-export const createDirectRoom = function(source, target, extraData, options) {
-	const rid = [source._id, target._id].sort().join('');
+const generateSubscription = (fname, name, user, extra) => ({
+	alert: false,
+	unread: 0,
+	userMentions: 0,
+	groupMentions: 0,
+	...user.customFields && { customFields: user.customFields },
+	...getDefaultSubscriptionPref(user),
+	...extra,
+	t: 'd',
+	fname,
+	name,
+	u: {
+		_id: user._id,
+		username: user.username,
+	},
+});
 
-	const now = new Date();
+const getFname = (members) => members.map(({ name, username }) => name || username).join(', ');
+const getName = (members) => members.map(({ username }) => username).join(', ');
 
-	const roomUpsertResult = Rooms.upsert({ _id: rid }, {
-		$set: {
-			usernames: [source.username, target.username],
-		},
-		$setOnInsert: Object.assign({
-			t: 'd',
-			msgs: 0,
-			ts: now,
-			usersCount: 2,
-		}, extraData),
-	});
+export const createDirectRoom = function(members, roomExtraData = {}, options = {}) {
+	if (members.length > (settings.get('DirectMesssage_maxUsers') || 1)) {
+		throw new Error('error-direct-message-max-user-exceeded');
+	}
 
-	const targetNotificationPref = getDefaultSubscriptionPref(target);
+	const sortedMembers = members.sort((u1, u2) => (u1.name || u1.username).localeCompare(u2.name || u2.username));
 
-	Subscriptions.upsert({ rid, 'u._id': target._id }, {
-		$setOnInsert: Object.assign({
-			fname: source.name,
-			name: source.username,
-			t: 'd',
-			open: false,
-			alert: false,
-			unread: 0,
-			userMentions: 0,
-			groupMentions: 0,
-			customFields: target.customFields,
-			u: {
-				_id: target._id,
-				username: target.username,
-			},
-			ts: now,
-			...targetNotificationPref,
-		}, options.subscriptionExtra),
-	});
+	const usernames = sortedMembers.map(({ username }) => username);
+	const uids = sortedMembers.map(({ _id }) => _id);
+
+	const room = Rooms.findDirectRoomContainingAllUserIDs(uids, { fields: { _id: 1 } });
 
-	const sourceNotificationPref = getDefaultSubscriptionPref(source);
+	const isNewRoom = !room;
 
-	Subscriptions.upsert({ rid, 'u._id': source._id }, {
-		$set: {
-			ls: now,
-			open: true,
-			...target.active === false && {
-				archived: true,
-			},
-		},
-		$setOnInsert: Object.assign({
-			fname: target.name,
-			name: target.username,
-			t: 'd',
-			alert: false,
-			unread: 0,
-			userMentions: 0,
-			groupMentions: 0,
-			customFields: source.customFields,
-			u: {
-				_id: source._id,
-				username: source.username,
-			},
-			ts: now,
-			...sourceNotificationPref,
-		}, options.subscriptionExtra),
+	const rid = room?._id || Rooms.insert({
+		t: 'd',
+		usernames,
+		usersCount: members.length,
+		msgs: 0,
+		ts: new Date(),
+		uids,
+		...roomExtraData,
 	});
 
+	if (members.length === 1) { // dm to yourself
+		Subscriptions.upsert({ rid, 'u._id': members[0]._id }, {
+			$set: { open: true },
+			$setOnInsert: generateSubscription(members[0].name || members[0].username, members[0].username, members[0], { ...options.subscriptionExtra }),
+		});
+	} else {
+		members.forEach((member) => {
+			const otherMembers = sortedMembers.filter(({ _id }) => _id !== member._id);
+
+			Subscriptions.upsert({ rid, 'u._id': member._id }, {
+				...options.creator === member._id && { $set: { open: true } },
+				$setOnInsert: generateSubscription(
+					getFname(otherMembers),
+					getName(otherMembers),
+					member,
+					{
+						...options.subscriptionExtra,
+						...options.creator !== member._id && { open: members.length > 2 },
+					},
+				),
+			});
+		});
+	}
+
 	// If the room is new, run a callback
-	if (roomUpsertResult.insertedId) {
+	if (isNewRoom) {
 		const insertedRoom = Rooms.findOneById(rid);
 
-		callbacks.run('afterCreateDirectRoom', insertedRoom, { from: source, to: target });
+		callbacks.run('afterCreateDirectRoom', insertedRoom, { members });
 	}
 
 	return {
 		_id: rid,
+		usernames,
 		t: 'd',
+		inserted: isNewRoom,
 	};
 };