[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.userIds,
 			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',
+			userIds: '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

@@ -492,74 +492,70 @@ integrations.triggerHandler = new class RocketChatIntegrationHandler {
 	}
 
 	getTriggersToExecute(room, message) {
-		const triggersToExecute = [];
+		const triggersToExecute = new Set();
 		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);
+							triggersToExecute.add(trigger);
 						}
 					}
 
-					if (id !== username && this.triggers[`@${ username }`]) {
+					room.uids.filter((uid) => this.triggers[`@${ uid }`]).forEach((uid) => {
+						for (const trigger of Object.values(this.triggers[`@${ uid }`])) {
+							triggersToExecute.add(trigger);
+						}
+					});
+
+					room.usernames.filter((username) => username !== message.u.username && this.triggers[`@${ username }`]).forEach((username) => {
 						for (const trigger of Object.values(this.triggers[`@${ username }`])) {
-							triggersToExecute.push(trigger);
+							triggersToExecute.add(trigger);
 						}
-					}
+					});
 					break;
-
 				case 'c':
 					if (this.triggers.all_public_channels) {
 						for (const trigger of Object.values(this.triggers.all_public_channels)) {
-							triggersToExecute.push(trigger);
+							triggersToExecute.add(trigger);
 						}
 					}
 
 					if (this.triggers[`#${ room._id }`]) {
 						for (const trigger of Object.values(this.triggers[`#${ room._id }`])) {
-							triggersToExecute.push(trigger);
+							triggersToExecute.add(trigger);
 						}
 					}
 
 					if (room._id !== room.name && this.triggers[`#${ room.name }`]) {
 						for (const trigger of Object.values(this.triggers[`#${ room.name }`])) {
-							triggersToExecute.push(trigger);
+							triggersToExecute.add(trigger);
 						}
 					}
 					break;
 
 				default:
 					if (this.triggers.all_private_groups) {
 						for (const trigger of Object.values(this.triggers.all_private_groups)) {
-							triggersToExecute.push(trigger);
+							triggersToExecute.add(trigger);
 						}
 					}
 
 					if (this.triggers[`#${ room._id }`]) {
 						for (const trigger of Object.values(this.triggers[`#${ room._id }`])) {
-							triggersToExecute.push(trigger);
+							triggersToExecute.add(trigger);
 						}
 					}
 
 					if (room._id !== room.name && this.triggers[`#${ room.name }`]) {
 						for (const trigger of Object.values(this.triggers[`#${ room.name }`])) {
-							triggersToExecute.push(trigger);
+							triggersToExecute.add(trigger);
 						}
 					}
 					break;
 			}
 		}
-		return triggersToExecute;
+		return [...triggersToExecute];
 	}
 
 	executeTriggers(...args) {

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 (this.isGroupChat(roomData)) {
+			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 && this.isGroupChat(roomData)) {
+			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.uids && room.uids.length > 2;
+	}
 }