[NEW] Livechat analytics

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

@@ -103,7 +103,7 @@ 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 }))) {
+			if (!Promise.await(Livechat.transfer(room, guest, { roomId: rid, departmentId: department, transferedBy: guest._id }))) {
 				return API.v1.failure();
 			}
 

app/livechat/server/config.js

@@ -124,32 +124,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_webhookUrl', false, {
 		type: 'string',
 		group: 'Livechat',
@@ -445,4 +419,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', 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,13 @@
+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;
+	}
+	const sentByVisitor = Boolean(message.token);
+	if (sentByVisitor) {
+		LivechatRooms.setVisitorLastMessageTimestampByRoomId(room._id, message.ts);
+	}
+	return message;
+}, callbacks.priority.HIGH, 'save-last-visitor-message-timestamp');

app/livechat/server/index.js

@@ -14,6 +14,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/Livechat.js

@@ -435,8 +435,33 @@ export const Livechat = {
 		}
 	},
 
+	saveTransferHistory(room, transferData) {
+		const transferedToDepartment = Boolean(transferData.departmentId);
+		const transferedToAgent = Boolean(transferData.userId);
+		const transfer = {
+			transferedBy: transferData.transferedBy,
+			ts: new Date(),
+		};
+		if (transferedToDepartment) {
+			transfer.scope = 'department';
+			transfer.previousDepartment = room.departmentId;
+			transfer.nextDepartment = transferData.departmentId;
+		}
+		if (transferedToAgent) {
+			transfer.scope = 'agent';
+			transfer.previousAgent = room.servedBy && room.servedBy._id;
+			transfer.nextAgent = transferData.userId;
+		}
+		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) {
@@ -842,6 +867,7 @@ export const Livechat = {
 				status,
 			});
 		});
+		callbacks.runAsync('livechat.agentStatusChanged', { userId, status });
 	},
 
 	allowAgentChangeServiceStatus(statusLivechat) {

app/livechat/server/methods/setDepartmentForVisitor.js

@@ -23,6 +23,7 @@ Meteor.methods({
 		const transferData = {
 			roomId,
 			departmentId,
+			transferedBy: visitor._id,
 		};
 
 		return Livechat.transfer(room, visitor, transferData);

app/livechat/server/methods/transfer.js

@@ -28,6 +28,7 @@ Meteor.methods({
 		}
 
 		const guest = LivechatVisitors.findOneById(room.v && room.v._id);
+		transferData.transferedBy = Meteor.userId();
 
 		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 { LivechatSessionsMonitor } from './statistics/LivechatSessionsMonitor';
 
 Meteor.startup(() => {
 	roomTypes.setRoomFind('l', (_id) => LivechatRooms.findOneById(_id));
@@ -69,4 +70,6 @@ Meteor.startup(() => {
 	}, callbacks.priority.LOW, 'cant-leave-room');
 
 	createLivechatQueueView();
+
+	new LivechatSessionsMonitor().start();
 });

app/livechat/server/statistics/LivechatSessionsMonitor.js

@@ -0,0 +1,86 @@
+import moment from 'moment';
+import { Meteor } from 'meteor/meteor';
+
+import { callbacks } from '../../../callbacks/server';
+import { LivechatSessions, Sessions, Users } from '../../../models/server';
+
+const formatDate = (dateTime = new Date()) => ({
+	date: parseInt(moment(dateTime).format('YYYYMMDD')),
+});
+
+export class LivechatSessionsMonitor {
+	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 };
+		LivechatSessions.createOrUpdate(data);
+	}
+
+	_updateSessionWhenAgentStop(userId) {
+		const data = { ...formatDate(), agentId: userId };
+		const livechatSession = LivechatSessions.findOne(data);
+		if (livechatSession) {
+			const stopedAt = new Date();
+			const availableTime = moment(stopedAt).diff(moment(new Date(livechatSession.lastStartedAt)), 'seconds');
+			LivechatSessions.updateLastStoppedAt({ ...data, availableTime, lastStopedAt: stopedAt });
+			LivechatSessions.updateServiceHistory({ ...data, historyObject: { startedAt: livechatSession.lastStartedAt, stopedAt } });
+		}
+	}
+}

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 LivechatSessions from './models/LivechatSessions';
 import ReadReceipts from './models/ReadReceipts';
 
 export { AppsLogsModel } from './models/apps-logs-model';
@@ -77,5 +78,6 @@ export {
 	LivechatRooms,
 	LivechatTrigger,
 	LivechatVisitors,
+	LivechatSessions,
 	ReadReceipts,
 };

app/models/server/models/LivechatRooms.js

@@ -438,6 +438,45 @@ export class LivechatRooms extends Base {
 
 		return this.remove(query);
 	}
+
+	updateTransferHistoryByRoomId(roomId, transfer) {
+		const query = {
+			_id: roomId,
+		};
+		const update = {
+			$addToSet: {
+				transferHistory: transfer,
+			},
+		};
+
+		return this.update(query, update);
+	}
+
+	setVisitorLastMessageTimestampByRoomId(roomId, lastMessageTs) {
+		const query = {
+			_id: roomId,
+		};
+		const update = {
+			$set: {
+				'v.lastMessageTs': lastMessageTs,
+			},
+		};
+
+		return this.update(query, update);
+	}
+
+	setVisitorInactivityInSecondsByRoomId(roomId, visitorInactivity) {
+		const query = {
+			_id: roomId,
+		};
+		const update = {
+			$set: {
+				'metrics.visitorInactivity': visitorInactivity,
+			},
+		};
+
+		return this.update(query, update);
+	}
 }
 
 export default new LivechatRooms(Rooms.model, true);