[NEW] Livechat analytics

app/apps/server/bridges/livechat.js

@@ -123,7 +123,7 @@ export class AppLivechatBridge {
 		return Livechat.transfer(
 			this.orch.getConverters().get('rooms').convertAppRoom(currentRoom),
 			this.orch.getConverters().get('visitors').convertAppVisitor(visitor),
-			{ userId: targetAgent.id, departmentId }
+			{ userId: targetAgent.id, departmentId },
 		);
 	}
 

app/livechat/lib/messageTypes.js

@@ -22,6 +22,34 @@ MessageTypes.registerType({
 	},
 });
 
+MessageTypes.registerType({
+	id: 'livechat_transfer_history',
+	system: true,
+	message: 'New_chat_transfer',
+	data(message) {
+		if (!message.transferData) {
+			return;
+		}
+		const from = message.transferData.transferredBy && (message.transferData.transferredBy.name || message.transferData.transferredBy.username);
+		const transferTypes = {
+			agent: () => TAPi18n.__('Livechat_transfer_to_agent', {
+				from,
+				to: message.transferData.transferredTo && (message.transferData.transferredTo.name || message.transferData.transferredTo.username),
+			}),
+			department: () => TAPi18n.__('Livechat_transfer_to_department', {
+				from,
+				to: message.transferData.nextDepartment && message.transferData.nextDepartment.name,
+			}),
+			queue: () => TAPi18n.__('Livechat_transfer_return_to_the_queue', {
+				from,
+			}),
+		};
+		return {
+			transfer: transferTypes[message.transferData.scope](),
+		};
+	},
+});
+
 MessageTypes.registerType({
 	id: 'livechat_video_call',
 	system: true,

app/livechat/server/api/v1/room.js

@@ -8,6 +8,7 @@ import { Messages, LivechatRooms } from '../../../../models';
 import { API } from '../../../../api';
 import { findGuest, findRoom, getRoom, settings, findAgent } from '../lib/livechat';
 import { Livechat } from '../../lib/Livechat';
+import { normalizeTransferredByData } from '../../lib/Helper';
 
 API.v1.addRoute('livechat/room', {
 	get() {
@@ -103,7 +104,10 @@ API.v1.addRoute('livechat/room.transfer', {
 			// update visited page history to not expire
 			Messages.keepHistoryForToken(token);
 
-			if (!Promise.await(Livechat.transfer(room, guest, { roomId: rid, departmentId: department }))) {
+			const { _id, username, name } = guest;
+			const transferredBy = normalizeTransferredByData({ _id, username, name, userType: 'visitor' }, room);
+
+			if (!Promise.await(Livechat.transfer(room, guest, { roomId: rid, departmentId: department, transferredBy }))) {
 				return API.v1.failure();
 			}
 

app/livechat/server/config.js

@@ -140,32 +140,6 @@ Meteor.startup(function() {
 		i18nLabel: 'Livechat_room_count',
 	});
 
-	settings.add('Livechat_agent_leave_action', 'none', {
-		type: 'select',
-		group: 'Livechat',
-		values: [
-			{ key: 'none', i18nLabel: 'None' },
-			{ key: 'forward', i18nLabel: 'Forward' },
-			{ key: 'close', i18nLabel: 'Close' },
-		],
-		i18nLabel: 'How_to_handle_open_sessions_when_agent_goes_offline',
-	});
-
-	settings.add('Livechat_agent_leave_action_timeout', 60, {
-		type: 'int',
-		group: 'Livechat',
-		enableQuery: { _id: 'Livechat_agent_leave_action', value: { $ne: 'none' } },
-		i18nLabel: 'How_long_to_wait_after_agent_goes_offline',
-		i18nDescription: 'Time_in_seconds',
-	});
-
-	settings.add('Livechat_agent_leave_comment', '', {
-		type: 'string',
-		group: 'Livechat',
-		enableQuery: { _id: 'Livechat_agent_leave_action', value: 'close' },
-		i18nLabel: 'Comment_to_leave_on_closing_session',
-	});
-
 	settings.add('Livechat_enabled_when_agent_idle', true, {
 		type: 'boolean',
 		group: 'Livechat',
@@ -475,4 +449,41 @@ Meteor.startup(function() {
 		i18nDescription: 'Data_processing_consent_text_description',
 		enableQuery: { _id: 'Livechat_force_accept_data_processing_consent', value: true },
 	});
+
+	settings.add('Livechat_agent_leave_action', 'none', {
+		type: 'select',
+		group: 'Livechat',
+		section: 'Sessions',
+		values: [
+			{ key: 'none', i18nLabel: 'None' },
+			{ key: 'forward', i18nLabel: 'Forward' },
+			{ key: 'close', i18nLabel: 'Close' },
+		],
+		i18nLabel: 'How_to_handle_open_sessions_when_agent_goes_offline',
+	});
+
+	settings.add('Livechat_agent_leave_action_timeout', 60, {
+		type: 'int',
+		group: 'Livechat',
+		section: 'Sessions',
+		enableQuery: { _id: 'Livechat_agent_leave_action', value: { $ne: 'none' } },
+		i18nLabel: 'How_long_to_wait_after_agent_goes_offline',
+		i18nDescription: 'Time_in_seconds',
+	});
+
+	settings.add('Livechat_agent_leave_comment', '', {
+		type: 'string',
+		group: 'Livechat',
+		section: 'Sessions',
+		enableQuery: { _id: 'Livechat_agent_leave_action', value: 'close' },
+		i18nLabel: 'Comment_to_leave_on_closing_session',
+	});
+
+	settings.add('Livechat_visitor_inactivity_timeout', 3600, {
+		type: 'int',
+		group: 'Livechat',
+		section: 'Sessions',
+		i18nLabel: 'How_long_to_wait_to_consider_visitor_abandonment',
+		i18nDescription: 'Time_in_seconds',
+	});
 });

app/livechat/server/hooks/processRoomAbandonment.js

@@ -0,0 +1,58 @@
+import moment from 'moment';
+
+import { settings } from '../../../settings';
+import { callbacks } from '../../../callbacks';
+import { LivechatRooms, Messages, LivechatOfficeHour } from '../../../models';
+
+const getSecondsWhenOfficeHoursIsDisabled = (room, agentLastMessage) => moment(new Date(room.closedAt)).diff(moment(new Date(agentLastMessage.ts)), 'seconds');
+const getOfficeHoursDictionary = () => LivechatOfficeHour.find().fetch().reduce((acc, day) => {
+	acc[day.day] = {
+		start: day.start,
+		finish: day.finish,
+		open: day.open,
+	};
+	return acc;
+}, {});
+const getSecondsSinceLastAgentResponse = (room, agentLastMessage) => {
+	if (!settings.get('Livechat_enable_office_hours')) {
+		return getSecondsWhenOfficeHoursIsDisabled(room, agentLastMessage);
+	}
+
+	let totalSeconds = 0;
+	const officeDays = getOfficeHoursDictionary();
+	const endOfConversation = moment(new Date(room.closedAt));
+	const startOfInactivity = moment(new Date(agentLastMessage.ts));
+	const daysOfInactivity = endOfConversation.clone().startOf('day').diff(startOfInactivity.clone().startOf('day'), 'days');
+	const inactivityDay = moment(new Date(agentLastMessage.ts));
+
+	for (let index = 0; index <= daysOfInactivity; index++) {
+		const today = inactivityDay.clone().format('dddd');
+		const officeDay = officeDays[today];
+		const startTodaysOfficeHour = moment(officeDay.start, 'HH:mm').add(index, 'days');
+		const endTodaysOfficeHour = moment(officeDay.finish, 'HH:mm').add(index, 'days');
+		if (officeDays[today].open) {
+			const firstDayOfInactivity = startOfInactivity.clone().format('D') === inactivityDay.clone().format('D');
+			const lastDayOfInactivity = endOfConversation.clone().format('D') === inactivityDay.clone().format('D');
+
+			if (!firstDayOfInactivity && !lastDayOfInactivity) {
+				totalSeconds += endTodaysOfficeHour.clone().diff(startTodaysOfficeHour, 'seconds');
+			} else {
+				const end = endOfConversation.isBefore(endTodaysOfficeHour) ? endOfConversation : endTodaysOfficeHour;
+				const start = firstDayOfInactivity ? inactivityDay : startTodaysOfficeHour;
+				totalSeconds += end.clone().diff(start, 'seconds');
+			}
+		}
+		inactivityDay.add(1, 'days');
+	}
+	return totalSeconds;
+};
+
+callbacks.add('livechat.closeRoom', (room) => {
+	const closedByAgent = room.closer !== 'visitor';
+	const wasTheLastMessageSentByAgent = room.lastMessage && !room.lastMessage.token;
+	if (closedByAgent && wasTheLastMessageSentByAgent) {
+		const agentLastMessage = Messages.findAgentLastMessageByVisitorLastMessageTs(room._id, room.v.lastMessageTs).fetch()[0];
+		const secondsSinceLastAgentResponse = getSecondsSinceLastAgentResponse(room, agentLastMessage);
+		LivechatRooms.setVisitorInactivityInSecondsByRoomId(room._id, secondsSinceLastAgentResponse);
+	}
+}, callbacks.priority.HIGH, 'process-room-abandonment');

app/livechat/server/hooks/saveLastVisitorMessageTs.js

@@ -0,0 +1,12 @@
+import { callbacks } from '../../../callbacks';
+import { LivechatRooms } from '../../../models';
+
+callbacks.add('afterSaveMessage', function(message, room) {
+	if (!(typeof room.t !== 'undefined' && room.t === 'l' && room.v && room.v.token)) {
+		return message;
+	}
+	if (message.token) {
+		LivechatRooms.setVisitorLastMessageTimestampByRoomId(room._id, message.ts);
+	}
+	return message;
+}, callbacks.priority.HIGH, 'save-last-visitor-message-timestamp');

app/livechat/server/index.js

@@ -15,6 +15,8 @@ import './hooks/RDStation';
 import './hooks/saveAnalyticsData';
 import './hooks/sendToCRM';
 import './hooks/sendToFacebook';
+import './hooks/processRoomAbandonment';
+import './hooks/saveLastVisitorMessageTs';
 import './methods/addAgent';
 import './methods/addManager';
 import './methods/changeLivechatStatus';

app/livechat/server/lib/Helper.js

@@ -257,3 +257,18 @@ export const forwardRoomToDepartment = async (room, guest, departmentId) => {
 
 	return true;
 };
+
+export const normalizeTransferredByData = (transferredBy, room) => {
+	if (!transferredBy || !room) {
+		throw new Error('You must provide "transferredBy" and "room" params to "getTransferredByData"');
+	}
+	const { servedBy: { _id: agentId } = {} } = room;
+	const { _id, username, name, userType: transferType } = transferredBy;
+	const type = transferType || (_id === agentId ? 'agent' : 'user');
+	return {
+		_id,
+		username,
+		name,
+		type,
+	};
+};

app/livechat/server/lib/Livechat.js

@@ -36,6 +36,7 @@ import { sendMessage } from '../../../lib/server/functions/sendMessage';
 import { updateMessage } from '../../../lib/server/functions/updateMessage';
 import { deleteMessage } from '../../../lib/server/functions/deleteMessage';
 import { FileUpload } from '../../../file-upload/server';
+import { normalizeTransferredByData } from './Helper';
 
 export const Livechat = {
 	Analytics,
@@ -430,7 +431,10 @@ export const Livechat = {
 	forwardOpenChats(userId) {
 		LivechatRooms.findOpenByAgent(userId).forEach((room) => {
 			const guest = LivechatVisitors.findOneById(room.v._id);
-			this.transfer(room, guest, { departmentId: guest.department });
+			const user = Users.findOneById(userId);
+			const { _id, username, name } = user;
+			const transferredBy = normalizeTransferredByData({ _id, username, name }, room);
+			this.transfer(room, guest, { roomId: room._id, transferredBy, departmentId: guest.department });
 		});
 	},
 
@@ -461,8 +465,38 @@ export const Livechat = {
 		}
 	},
 
+	saveTransferHistory(room, transferData) {
+		const { departmentId: previousDepartment } = room;
+		const { department: nextDepartment, transferredBy, transferredTo, scope } = transferData;
+		check(transferredBy, Match.ObjectIncluding({
+			_id: String,
+			username: String,
+			name: String,
+			type: String,
+		}));
+		const user = Users.findOneByUsername(transferredBy.username);
+		const transfer = {
+			transferData: {
+				transferredBy,
+				ts: new Date(),
+				scope: scope || (nextDepartment ? 'department' : 'agent'),
+				...previousDepartment && { previousDepartment },
+				...nextDepartment && { nextDepartment },
+				...transferredTo && { transferredTo },
+			},
+		};
+		return Messages.createTransferHistoryWithRoomIdMessageAndUser(room._id, '', user, transfer);
+	},
+
 	async transfer(room, guest, transferData) {
-		return RoutingManager.transferRoom(room, guest, transferData);
+		const result = await RoutingManager.transferRoom(room, guest, transferData);
+		if (!result) {
+			return false;
+		}
+		if (transferData.departmentId) {
+			transferData.department = LivechatDepartment.findOneById(transferData.departmentId, { fields: { name: 1 } });
+		}
+		return this.saveTransferHistory(room, transferData);
 	},
 
 	returnRoomAsInquiry(rid, departmentId) {
@@ -489,7 +523,9 @@ export const Livechat = {
 		if (!inquiry) {
 			return false;
 		}
-
+		const transferredBy = normalizeTransferredByData(user, room);
+		const transferData = { roomId: rid, scope: 'queue', departmentId, transferredBy };
+		this.saveTransferHistory(room, transferData);
 		return RoutingManager.unassignAgent(inquiry, departmentId);
 	},
 
@@ -866,6 +902,7 @@ export const Livechat = {
 	},
 
 	notifyAgentStatusChanged(userId, status) {
+		callbacks.runAsync('livechat.agentStatusChanged', { userId, status });
 		if (!settings.get('Livechat_show_agent_info')) {
 			return;
 		}