[NEW] Livechat analytics

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 } = guest;
+			const transferredBy = normalizeTransferredByData({ _id, username, 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,17 @@ 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, userType: transferType } = transferredBy;
+	const type = transferType || (_id === agentId ? 'agent' : 'user');
+	return {
+		_id,
+		username,
+		type,
+	};
+};

app/livechat/server/lib/Livechat.js

@@ -461,8 +461,32 @@ export const Livechat = {
 		}
 	},
 
+	saveTransferHistory(room, transferData) {
+		const { departmentId: previousDepartment } = room;
+		const { departmentId: nextDepartment, transferredBy, transferredTo } = transferData;
+		check(transferredBy, Match.ObjectIncluding({
+			_id: String,
+			username: String,
+			type: String,
+		}));
+		const transfer = {
+			transferredBy,
+			ts: new Date(),
+			scope: nextDepartment ? 'department' : 'agent',
+			...previousDepartment && { previousDepartment },
+			...nextDepartment && { nextDepartment },
+			...transferredTo && { transferredTo },
+		};
+		LivechatRooms.updateTransferHistoryByRoomId(room._id, transfer);
+	},
+
 	async transfer(room, guest, transferData) {
-		return RoutingManager.transferRoom(room, guest, transferData);
+		const result = await RoutingManager.transferRoom(room, guest, transferData);
+		if (!result) {
+			return false;
+		}
+		this.saveTransferHistory(room, transferData);
+		return true;
 	},
 
 	returnRoomAsInquiry(rid, departmentId) {
@@ -876,6 +900,7 @@ export const Livechat = {
 				status,
 			});
 		});
+		callbacks.runAsync('livechat.agentStatusChanged', { userId, status });
 	},
 
 	allowAgentChangeServiceStatus(statusLivechat) {

app/livechat/server/methods/setDepartmentForVisitor.js

@@ -3,6 +3,7 @@ import { check } from 'meteor/check';
 
 import { LivechatRooms, Messages, LivechatVisitors } from '../../../models';
 import { Livechat } from '../lib/Livechat';
+import { normalizeTransferredByData } from '../lib/Helper';
 
 Meteor.methods({
 	'livechat:setDepartmentForVisitor'({ roomId, visitorToken, departmentId } = {}) {
@@ -23,6 +24,7 @@ Meteor.methods({
 		const transferData = {
 			roomId,
 			departmentId,
+			transferredBy: normalizeTransferredByData(visitor, room),
 		};
 
 		return Livechat.transfer(room, visitor, transferData);

app/livechat/server/methods/transfer.js

@@ -2,8 +2,9 @@ import { Meteor } from 'meteor/meteor';
 import { Match, check } from 'meteor/check';
 
 import { hasPermission } from '../../../authorization';
-import { LivechatRooms, Subscriptions, LivechatVisitors } from '../../../models';
+import { LivechatRooms, Subscriptions, LivechatVisitors, Users } from '../../../models';
 import { Livechat } from '../lib/Livechat';
+import { normalizeTransferredByData } from '../lib/Helper';
 
 Meteor.methods({
 	'livechat:transfer'(transferData) {
@@ -32,6 +33,11 @@ Meteor.methods({
 		}
 
 		const guest = LivechatVisitors.findOneById(room.v && room.v._id);
+		transferData.transferredBy = normalizeTransferredByData(Meteor.user() || {}, room);
+		if (transferData.userId) {
+			const userToTransfer = Users.findOneById(transferData.userId);
+			transferData.transferredTo = { _id: userToTransfer._id, username: userToTransfer.username };
+		}
 
 		return Livechat.transfer(room, guest, transferData);
 	},

app/livechat/server/startup.js

@@ -10,6 +10,7 @@ import { LivechatInquiry } from '../lib/LivechatInquiry';
 import { LivechatDepartment, LivechatDepartmentAgents } from '../../models/server';
 import { RoutingManager } from './lib/RoutingManager';
 import { createLivechatQueueView } from './lib/Helper';
+import { LivechatAgentActivityMonitor } from './statistics/LivechatAgentActivityMonitor';
 
 Meteor.startup(() => {
 	roomTypes.setRoomFind('l', (_id) => LivechatRooms.findOneById(_id));
@@ -69,4 +70,6 @@ Meteor.startup(() => {
 	}, callbacks.priority.LOW, 'cant-leave-room');
 
 	createLivechatQueueView();
+
+	new LivechatAgentActivityMonitor().start();
 });

app/livechat/server/statistics/LivechatAgentActivityMonitor.js

@@ -0,0 +1,86 @@
+import moment from 'moment';
+import { Meteor } from 'meteor/meteor';
+
+import { callbacks } from '../../../callbacks/server';
+import { LivechatAgentActivity, Sessions, Users } from '../../../models/server';
+
+const formatDate = (dateTime = new Date()) => ({
+	date: parseInt(moment(dateTime).format('YYYYMMDD')),
+});
+
+export class LivechatAgentActivityMonitor {
+	constructor() {
+		this._handleMeteorConnection = this._handleMeteorConnection.bind(this);
+		this._handleAgentStatusChanged = this._handleAgentStatusChanged.bind(this);
+		this._handleUserStatusLivechatChanged = this._handleUserStatusLivechatChanged.bind(this);
+	}
+
+	start() {
+		this._setupListeners();
+	}
+
+	_setupListeners() {
+		Meteor.onConnection(this._handleMeteorConnection);
+		callbacks.add('livechat.agentStatusChanged', this._handleAgentStatusChanged);
+		callbacks.add('livechat.setUserStatusLivechat', this._handleUserStatusLivechatChanged);
+	}
+
+	_handleMeteorConnection(connection) {
+		const session = Sessions.findOne({ sessionId: connection.id });
+		if (!session) {
+			return;
+		}
+		const user = Users.findOneById(session.userId);
+		if (user && user.status !== 'offline' && user.statusLivechat === 'available') {
+			this._createOrUpdateSession(user._id);
+		}
+		connection.onClose(() => {
+			if (session) {
+				this._updateSessionWhenAgentStop(session.userId);
+			}
+		});
+	}
+
+	_handleAgentStatusChanged({ userId, status }) {
+		const user = Users.findOneById(userId);
+		if (!user || user.statusLivechat !== 'available') {
+			return;
+		}
+
+		if (status !== 'offline') {
+			this._createOrUpdateSession(userId);
+		} else {
+			this._updateSessionWhenAgentStop(userId);
+		}
+	}
+
+	_handleUserStatusLivechatChanged({ userId, status }) {
+		const user = Users.findOneById(userId);
+		if (user && user.status === 'offline') {
+			return;
+		}
+
+		if (status === 'available') {
+			this._createOrUpdateSession(userId);
+		}
+		if (status === 'not-available') {
+			this._updateSessionWhenAgentStop(userId);
+		}
+	}
+
+	_createOrUpdateSession(userId) {
+		const data = { ...formatDate(), agentId: userId };
+		LivechatAgentActivity.createOrUpdate(data);
+	}
+
+	_updateSessionWhenAgentStop(userId) {
+		const data = { ...formatDate(), agentId: userId };
+		const livechatSession = LivechatAgentActivity.findOne(data);
+		if (livechatSession) {
+			const stoppedAt = new Date();
+			const availableTime = moment(stoppedAt).diff(moment(new Date(livechatSession.lastStartedAt)), 'seconds');
+			LivechatAgentActivity.updateLastStoppedAt({ ...data, availableTime, lastStopedAt: stoppedAt });
+			LivechatAgentActivity.updateServiceHistory({ ...data, serviceHistory: { startedAt: livechatSession.lastStartedAt, stopedAt: stoppedAt } });
+		}
+	}
+}

app/models/server/index.js

@@ -32,6 +32,7 @@ import LivechatPageVisited from './models/LivechatPageVisited';
 import LivechatRooms from './models/LivechatRooms';
 import LivechatTrigger from './models/LivechatTrigger';
 import LivechatVisitors from './models/LivechatVisitors';
+import LivechatAgentActivity from './models/LivechatAgentActivity';
 import ReadReceipts from './models/ReadReceipts';
 
 export { AppsLogsModel } from './models/apps-logs-model';
@@ -77,5 +78,6 @@ export {
 	LivechatRooms,
 	LivechatTrigger,
 	LivechatVisitors,
+	LivechatAgentActivity,
 	ReadReceipts,
 };