[NEW][ENTERPRISE] Automatic transfer of unanswered conversations to another agent

app/livechat/server/lib/RoutingManager.js

@@ -13,6 +13,7 @@ import {
 import { callbacks } from '../../../callbacks/server';
 import { LivechatRooms, Rooms, Messages, Users, LivechatInquiry } from '../../../models/server';
 import { Apps, AppEvents } from '../../../apps/server';
+import { Livechat } from './Livechat';
 
 export const RoutingManager = {
 	methodName: null,
@@ -37,11 +38,11 @@ export const RoutingManager = {
 		return this.getMethod().config || {};
 	},
 
-	async getNextAgent(department) {
+	async getNextAgent(department, ignoredUserId) {
 		let agent = callbacks.run('livechat.beforeGetNextAgent', department);
 
 		if (!agent) {
-			agent = await this.getMethod().getNextAgent(department);
+			agent = await this.getMethod().getNextAgent(department, ignoredUserId);
 		}
 
 		return agent;
@@ -151,6 +152,17 @@ export const RoutingManager = {
 	},
 
 	async transferRoom(room, guest, transferData) {
+		if (transferData.ignoredUserId) {
+			const agent = await RoutingManager.getNextAgent(transferData.departmentId, transferData.ignoredUserId);
+			if (agent) {
+				transferData.userId = agent.agentId;
+				return forwardRoomToAgent(room, transferData);
+			}
+			if (!RoutingManager.getConfig().autoAssignAgent) {
+				return Livechat.returnRoomAsInquiry(room._id, room.departmentId);
+			}
+		}
+
 		if (transferData.departmentId) {
 			return forwardRoomToDepartment(room, guest, transferData);
 		}

app/livechat/server/lib/routing/AutoSelection.js

@@ -19,12 +19,12 @@ class AutoSelection {
 		};
 	}
 
-	getNextAgent(department) {
+	getNextAgent(department, ignoredUserId) {
 		if (department) {
-			return LivechatDepartmentAgents.getNextAgentForDepartment(department);
+			return LivechatDepartmentAgents.getNextAgentForDepartment(department, ignoredUserId);
 		}
 
-		return Users.getNextAgent();
+		return Users.getNextAgent(ignoredUserId);
 	}
 
 	delegateAgent(agent) {

app/livechat/server/lib/routing/External.js

@@ -18,10 +18,14 @@ class ExternalQueue {
 		};
 	}
 
-	getNextAgent(department) {
+	getNextAgent(department, ignoredUserId) {
 		for (let i = 0; i < 10; i++) {
 			try {
-				const queryString = department ? `?departmentId=${ department }` : '';
+				let queryString = department ? `?departmentId=${ department }` : '';
+				if (ignoredUserId) {
+					const ignoredUserIdParam = `ignoredUserId=${ ignoredUserId }`;
+					queryString = queryString.startsWith('?') ? `${ queryString }&${ ignoredUserIdParam }` : `?${ ignoredUserIdParam }`;
+				}
 				const result = HTTP.call('GET', `${ settings.get('Livechat_External_Queue_URL') }${ queryString }`, {
 					headers: {
 						'User-Agent': 'RocketChat Server',

app/models/server/models/LivechatDepartmentAgents.js

@@ -54,7 +54,7 @@ export class LivechatDepartmentAgents extends Base {
 		this.remove({ departmentId });
 	}
 
-	getNextAgentForDepartment(departmentId) {
+	getNextAgentForDepartment(departmentId, ignoredUserId) {
 		const agents = this.findByDepartmentId(departmentId).fetch();
 
 		if (agents.length === 0) {
@@ -70,6 +70,7 @@ export class LivechatDepartmentAgents extends Base {
 			username: {
 				$in: onlineUsernames,
 			},
+			...ignoredUserId && { agentId: { $ne: ignoredUserId } },
 		};
 
 		const sort = {

app/models/server/models/Users.js

@@ -174,8 +174,11 @@ export class Users extends Base {
 		return this.find(query);
 	}
 
-	getNextAgent() {
-		const query = queryStatusAgentOnline();
+	getNextAgent(ignoredUserId) {
+		const extraFilters = {
+			...ignoredUserId && { _id: { $ne: { ignoredUserId } } },
+		};
+		const query = queryStatusAgentOnline(extraFilters);
 
 		const collectionObj = this.model.rawCollection();
 		const findAndModify = Meteor.wrapAsync(collectionObj.findAndModify, collectionObj);

app/models/server/raw/Users.js

@@ -133,9 +133,9 @@ export class UsersRaw extends BaseRaw {
 		return this.col.distinct('federation.origin', { federation: { $exists: true } });
 	}
 
-	async getNextLeastBusyAgent(department) {
+	async getNextLeastBusyAgent(department, ignoredUserId) {
 		const aggregate = [
-			{ $match: { status: { $exists: true, $ne: 'offline' }, statusLivechat: 'available', roles: 'livechat-agent' } },
+			{ $match: { status: { $exists: true, $ne: 'offline' }, statusLivechat: 'available', roles: 'livechat-agent', ...ignoredUserId && { _id: { $ne: ignoredUserId } } } },
 			{ $lookup: {
 				from: 'rocketchat_subscription',
 				let: { id: '$_id' },

ee/app/livechat-enterprise/server/hooks/scheduleAutoTransfer.ts

@@ -0,0 +1,58 @@
+import { AutoTransferMonitor } from '../lib/AutoTransferMonitor';
+import { callbacks } from '../../../../../app/callbacks/server';
+import { settings } from '../../../../../app/settings/server';
+import { RoutingManager } from '../../../../../app/livechat/server/lib/RoutingManager';
+
+
+const scheduleAutoTransferJob = async (roomId: string): Promise<any> => {
+	if (!roomId || roomId.length <= 0) {
+		return;
+	}
+
+	const timeout = settings.get('Livechat_auto_transfer_chat_if_no_response_routing');
+	if (!timeout || timeout <= 0) {
+		return;
+	}
+
+	await AutoTransferMonitor.Instance.startMonitoring(roomId, timeout as number);
+};
+
+const handleLivechatNewRoomCallback = async (room: any = {}): Promise<any> => {
+	if (room && RoutingManager.getConfig().autoAssignAgent) {
+		const { _id } = room;
+		await scheduleAutoTransferJob(_id);
+	}
+	return room;
+};
+
+const handleAfterTakeInquiryCallback = async (inquiry: any = {}): Promise<any> => {
+	if (inquiry && !RoutingManager.getConfig().autoAssignAgent) {
+		const { rid } = inquiry;
+		await scheduleAutoTransferJob(rid);
+	}
+	return inquiry;
+};
+
+const cancelAutoTransferJob = async (message: any = {}, room: any = {}): Promise<any> => {
+	const { _id: rid, t } = room;
+	const { token } = message;
+
+	if (!rid || !message || rid === '' || t !== 'l' || token) {
+		return;
+	}
+
+	await AutoTransferMonitor.Instance.stopMonitoring(rid);
+};
+
+settings.get('Livechat_auto_transfer_chat_if_no_response_routing', function(_, value) {
+	if (!value || value === 0) {
+		callbacks.remove('livechat.newRoom', 'livechat-schedule-auto-transfer-job');
+		callbacks.remove('livechat.afterTakeInquiry', 'livechat-livechat-auto-transfer-job-inquiry');
+		callbacks.remove('afterSaveMessage', 'livechat-cancel-auto-transfer-job');
+		return;
+	}
+
+	callbacks.add('livechat.newRoom', handleLivechatNewRoomCallback, callbacks.priority.MEDIUM, 'livechat-schedule-auto-transfer-job');
+	callbacks.add('livechat.afterTakeInquiry', handleAfterTakeInquiryCallback, callbacks.priority.MEDIUM, 'livechat-livechat-auto-transfer-job-inquiry');
+	callbacks.add('afterSaveMessage', cancelAutoTransferJob, callbacks.priority.HIGH, 'livechat-cancel-auto-transfer-job');
+});

ee/app/livechat-enterprise/server/index.js

@@ -25,6 +25,7 @@ import './hooks/onCheckRoomParamsApi';
 import './hooks/onLoadConfigApi';
 import './hooks/onCloseLivechat';
 import './hooks/onSaveVisitorInfo';
+import './hooks/scheduleAutoTransfer';
 import './lib/routing/LoadBalancing';
 import { onLicense } from '../../license/server';
 import './business-hour';

ee/app/livechat-enterprise/server/lib/AutoTransferMonitor.ts

@@ -0,0 +1,52 @@
+import Agenda from 'agenda';
+import { MongoInternals } from 'meteor/mongo';
+
+import { Users } from '../../../../../app/models/server';
+import { autoTransferVisitorJob } from './jobs';
+
+export class AutoTransferMonitor {
+	private static _instance: AutoTransferMonitor;
+
+	schedular: Agenda;
+
+	userToPerformAutomaticTransfer: any;
+
+	private constructor(schedular: Agenda) {
+		this.schedular = schedular;
+	}
+
+	public static get Instance(): AutoTransferMonitor {
+		if (!this._instance) {
+			const schedular = new Agenda({
+				mongo: (MongoInternals.defaultRemoteCollectionDriver().mongo as any).client.db(),
+				db: { collection: 'livechat_scheduler' },
+				// this ensures the same job doesn't get executed multiple times in a cluster
+				defaultConcurrency: 1,
+			});
+			this._instance = new this(schedular);
+			this._instance.schedular.start();
+			const user = Users.findOneById('rocket.cat');
+			this._instance.userToPerformAutomaticTransfer = user;
+		}
+		return this._instance;
+	}
+
+	public async startMonitoring(roomId: string, timeout: number): Promise<void> {
+		const jobName = `livechat-auto-transfer-${ roomId }`;
+		const when = this.addMinutesToDate(new Date(), timeout);
+
+		this.schedular.define(jobName, autoTransferVisitorJob);
+
+		await this.schedular.schedule(when, jobName, { roomId, transferredBy: this.userToPerformAutomaticTransfer });
+	}
+
+	public async stopMonitoring(roomId: string): Promise<void> {
+		const jobName = `livechat-auto-transfer-${ roomId }`;
+
+		await this.schedular.cancel({ name: jobName });
+	}
+
+	private addMinutesToDate(date: Date, minutes: number): Date {
+		return new Date(date.getTime() + minutes * 1000 * 60);
+	}
+}

ee/app/livechat-enterprise/server/lib/Helper.js

@@ -10,12 +10,14 @@ import {
 	LivechatRooms,
 	Messages,
 	LivechatCustomField,
+	LivechatVisitors,
 } from '../../../../../app/models/server';
 import { Rooms as RoomRaw } from '../../../../../app/models/server/raw';
 import { settings } from '../../../../../app/settings';
 import { RoutingManager } from '../../../../../app/livechat/server/lib/RoutingManager';
 import { dispatchAgentDelegated } from '../../../../../app/livechat/server/lib/Helper';
 import notifications from '../../../../../app/notifications/server/lib/Notifications';
+import { Livechat } from '../../../../../app/livechat/server';
 
 export const getMaxNumberSimultaneousChat = ({ agentId, departmentId }) => {
 	if (agentId) {
@@ -244,3 +246,24 @@ export const getLivechatQueueInfo = async (room) => {
 
 	return normalizeQueueInfo(inq);
 };
+
+export const transferToNewAgent = async (roomId, transferredBy) => {
+	const room = await LivechatRooms.findOneById(roomId);
+	const timeout = await settings.get('Livechat_auto_transfer_chat_if_no_response_routing');
+
+	const { departmentId, v: { token }, servedBy: { _id: ignoredUserId, username } = {} } = room;
+
+	const guest = await LivechatVisitors.getVisitorByToken(token, {});
+	const transferData = {
+		ignoredUserId,
+		departmentId,
+		transferredBy,
+		comment: `The chat was transferred because ${ username } had not replied for ${ timeout } minutes`,
+	};
+
+	try {
+		await Livechat.transfer(room, guest, transferData);
+	} catch (err) {
+		console.error(`Error occurred while transferring chat. Details: ${ err.message }`);
+	}
+};

ee/app/livechat-enterprise/server/lib/jobs.ts

@@ -0,0 +1,10 @@
+import { transferToNewAgent } from './Helper';
+
+export const autoTransferVisitorJob = async ({ attrs: { data } }: any = {}): Promise<void> => {
+	const { roomId, transferredBy } = data;
+	try {
+		await transferToNewAgent(roomId, transferredBy);
+	} catch (err) {
+		console.error(err);
+	}
+};

ee/app/livechat-enterprise/server/lib/routing/LoadBalancing.js

@@ -19,8 +19,8 @@ class LoadBalancing {
 		};
 	}
 
-	async getNextAgent(department) {
-		const nextAgent = await Users.getNextLeastBusyAgent(department);
+	async getNextAgent(department, ignoredUserId) {
+		const nextAgent = await Users.getNextLeastBusyAgent(department, ignoredUserId);
 		if (!nextAgent) {
 			return;
 		}

ee/app/livechat-enterprise/server/settings.js

@@ -90,6 +90,19 @@ export const createSettings = () => {
 		],
 	});
 
+	settings.add('Livechat_auto_transfer_chat_if_no_response_routing', 0, {
+		type: 'int',
+		group: 'Omnichannel',
+		section: 'Routing',
+		i18nLabel: 'Livechat_Auto_transfer_chat_if_no_response',
+		i18nDescription: 'Livechat_Auto_transfer_chat_if_no_response_description',
+		enterprise: true,
+		invalidValue: 0,
+		modules: [
+			'livechat-enterprise',
+		],
+	});
+
 	settings.addGroup('Omnichannel', function() {
 		this.section('Business_Hours', function() {
 			this.add('Livechat_business_hour_type', 'Single', {

packages/rocketchat-i18n/i18n/en.i18n.json

@@ -2338,6 +2338,8 @@
   "Livechat_Agents": "Agents",
   "Livechat_AllowedDomainsList": "Livechat Allowed Domains",
   "Livechat_Appearance": "Livechat Appearance",
+  "Livechat_Auto_transfer_chat_if_no_response": "Auto-Transfer to another agent, if the current agent hasn't responsed in the specified time (in minutes)",
+  "Livechat_Auto_transfer_chat_if_no_response_description" : "This applied when the chat has just started. All the following responses can be longer and won't result in transfer",
   "Livechat_business_hour_type": "Business Hour Type (Single or Multiple)",
   "Livechat_chat_transcript_sent": "Chat transcript sent: __transcript__",
   "Livechat_custom_fields_options_placeholder": "Comma-separated list used to select a pre-configured value. Spaces between elements are not accepted.",