feat: External Call History (#40658)

Author: pierre-lehnen-rc

apps/meteor/client/views/mediaCallHistory/CallHistoryPage.tsx

@@ -46,7 +46,7 @@ const getStateFilter = <T extends string[]>(states: T): T | [...T, 'error'] | un
 };
 
 const getContact = (item: Serialized<CallHistoryItem>): CallHistoryContact => {
-	if (item.external) {
+	if (item.type !== 'media-call' || item.external) {
 		return getExternalContact(item);
 	}
 

apps/meteor/client/views/mediaCallHistory/CallHistoryRowExternalUser.tsx

@@ -22,6 +22,10 @@ const CallHistoryRowExternalUser = ({ _id, contact, type, status, duration, time
 		if (state === 'unavailable') {
 			return [];
 		}
+		if (!('number' in contact) || !contact.number) {
+			return [];
+		}
+
 		const disabled = state !== 'available';
 		return [
 			{

apps/meteor/client/views/mediaCallHistory/MediaCallHistoryExternal.tsx

@@ -25,6 +25,19 @@ export const getExternalContact = (item: ExternalCallEndpointData['item']): Call
 		};
 	}
 
+	if (item.contactNumber) {
+		return {
+			number: item.contactNumber,
+			name: item.contactName,
+		};
+	}
+
+	if (item.contactName) {
+		return {
+			name: item.contactName,
+		};
+	}
+
 	return { unknown: true };
 };
 
@@ -50,6 +63,9 @@ const MediaCallHistoryExternal = ({ data, onClose }: MediaCallHistoryExternalPro
 		if (state !== 'available') {
 			return {};
 		}
+		if (!('number' in contact) || !contact.number) {
+			return {};
+		}
 		return {
 			voiceCall: () => toggleWidget(contact),
 		};

apps/meteor/ee/server/settings/voip.ts

@@ -82,6 +82,47 @@ export function addSettings(): Promise<void> {
 						invalidValue: 5060,
 					});
 				});
+
+				await this.section('VoIP_TeamCollab_ExternalCallHistory', async function () {
+					await this.add('VoIP_TeamCollab_ExternalCallHistory_Enabled', false, {
+						type: 'boolean',
+						public: true,
+						invalidValue: false,
+						i18nDescription: 'VoIP_TeamCollab_ExternalCallHistory_Enabled_Description',
+					});
+
+					const enableQuery = { _id: 'VoIP_TeamCollab_ExternalCallHistory_Enabled', value: true };
+
+					await this.add('VoIP_TeamCollab_ExternalCallHistory_Host', '', {
+						type: 'string',
+						public: false,
+						invalidValue: '',
+						enableQuery,
+					});
+
+					await this.add('VoIP_TeamCollab_ExternalCallHistory_User', '', {
+						type: 'string',
+						public: false,
+						invalidValue: '',
+						enableQuery,
+					});
+
+					await this.add('VoIP_TeamCollab_ExternalCallHistory_Password', '', {
+						type: 'password',
+						public: false,
+						secret: true,
+						invalidValue: '',
+						enableQuery,
+					});
+
+					await this.add('VoIP_TeamCollab_ExternalCallHistory_Timeout', 10000, {
+						type: 'int',
+						public: false,
+						invalidValue: 10000,
+						enableQuery,
+						i18nDescription: 'VoIP_TeamCollab_ExternalCallHistory_Timeout_Description',
+					});
+				});
 			},
 		);
 	});

apps/meteor/jest.config.ts

@@ -44,6 +44,7 @@ export default {
 				'<rootDir>/app/utils/lib/**.spec.ts',
 				'<rootDir>/server/lib/auditServerEvents/**.spec.ts',
 				'<rootDir>/server/services/import/**/*.spec.ts',
+				'<rootDir>/server/services/call-history/**/*.spec.ts',
 				'<rootDir>/server/settings/lib/**.spec.ts',
 				'<rootDir>/server/cron/**.spec.ts',
 				'<rootDir>/app/api/server/**.spec.ts',

apps/meteor/server/services/call-history/logger.ts

@@ -0,0 +1,3 @@
+import { Logger } from '@rocket.chat/logger';
+
+export const logger = new Logger('CallHistory');

apps/meteor/server/services/call-history/mitel/definition.ts

@@ -0,0 +1,23 @@
+export type MitelConfig = {
+	host: string;
+	username: string;
+	password: string;
+	timeout?: number;
+};
+
+export type MitelCallItem = {
+	directoryNumber?: string;
+	name?: string;
+	callIdentity?: string;
+	dateTime: Date | null;
+	timeZone?: string;
+	duration: number;
+	typeOfCall?: 'incoming-answered' | 'incoming-missed' | 'outgoing';
+	transferredCall: boolean;
+	divertedCall: boolean;
+	firstDialledNumber?: string;
+	remoteNumber?: string;
+	directoryNumber2?: string;
+	name2?: string;
+	infoText2?: string;
+};

apps/meteor/server/services/call-history/mitel/fetchMitelHistory.ts

@@ -0,0 +1,62 @@
+import { serverFetch } from '@rocket.chat/server-fetch';
+
+import type { MitelConfig } from './definition';
+import { logger } from '../logger';
+
+export async function fetchMitelHistory(sipExtension: string, config: MitelConfig): Promise<string | null> {
+	if (!sipExtension) {
+		return null;
+	}
+
+	const directoryNumber = sipExtension.replace(/\D/g, '');
+	if (!directoryNumber) {
+		logger.warn({ msg: "User's sip extension does not include numeric digits", sipExtension });
+		return null;
+	}
+
+	const separator = config.host.endsWith('/') ? '' : '/';
+	const endpointUrl = `${config.host}${separator}callHistory/${directoryNumber}`;
+
+	let response: Awaited<ReturnType<typeof serverFetch>>;
+
+	try {
+		logger.info({ msg: 'Fetching External call history', directoryNumber });
+		response = await serverFetch(endpointUrl, {
+			method: 'GET',
+			// URL can only be configured by users with enough privileges, so it's fine to skip ssrf validation here
+			ignoreSsrfValidation: true,
+			auth: {
+				type: 'digest',
+				username: config.username,
+				password: config.password,
+			},
+		});
+	} catch (err) {
+		logger.error({ msg: 'Failed to fetch External Call History', err });
+		return null;
+	}
+
+	if (response.status !== 200) {
+		logger.error({
+			msg: 'Failed to fetch External Call History',
+			status: response.status,
+		});
+
+		try {
+			response.body?.resume();
+		} catch {
+			// ignore errors here
+		}
+		return null;
+	}
+
+	try {
+		return Buffer.from(await response.arrayBuffer()).toString('utf8');
+	} catch (err) {
+		logger.error({
+			msg: 'Failed to read External Call History',
+			err,
+		});
+		return null;
+	}
+}

apps/meteor/server/services/call-history/mitel/importHistoryForUser.ts

@@ -0,0 +1,82 @@
+import type { IUser } from '@rocket.chat/core-typings';
+import { Users } from '@rocket.chat/models';
+
+import type { MitelConfig } from './definition';
+import { fetchMitelHistory } from './fetchMitelHistory';
+import { importHistoryItems } from './importHistoryItems';
+import { logger } from '../logger';
+import { parseMitelJSON } from './parse/parseMitelJSON';
+
+async function getUserDirectoryNumber(uid: IUser['_id']): Promise<string | null> {
+	const user = await Users.findOneById<Pick<IUser, '_id' | 'freeSwitchExtension'>>(uid, { projection: { freeSwitchExtension: 1 } });
+	return user?.freeSwitchExtension || null;
+}
+
+async function processFetchedHistory(uid: IUser['_id'], result: string | null): Promise<void> {
+	if (!result) {
+		return;
+	}
+
+	try {
+		const callItems = parseMitelJSON(result);
+		if (!callItems) {
+			return;
+		}
+
+		await importHistoryItems(uid, callItems);
+	} catch (err) {
+		logger.error({ msg: 'Unexpected error processing external call history', err });
+	}
+}
+
+async function fetchAndImportHistory(user: { directoryNumber: string; uid: IUser['_id'] }, config: MitelConfig): Promise<void> {
+	const { timeout } = config;
+
+	if (!timeout) {
+		const result = await fetchMitelHistory(user.directoryNumber, config);
+		return processFetchedHistory(user.uid, result);
+	}
+
+	// Set a timeout so that the request to the external service doesn't prevent our API request from working
+	let promiseDecided = false;
+	return new Promise((resolve, reject) => {
+		fetchMitelHistory(user.directoryNumber, config)
+			.then((result) => {
+				const newPromise = processFetchedHistory(user.uid, result);
+
+				if (promiseDecided) {
+					return;
+				}
+
+				promiseDecided = true;
+				// If the request completes successfully we can process its data, even if the timeout was already reached
+				newPromise.then(resolve);
+			})
+			.catch((err) => {
+				if (promiseDecided) {
+					logger.error({ msg: 'Unexpected error on external call history processing', err });
+					return;
+				}
+				promiseDecided = true;
+				reject(err as Error);
+			});
+
+		setTimeout(() => {
+			if (promiseDecided) {
+				return;
+			}
+
+			promiseDecided = true;
+			resolve();
+		}, timeout);
+	});
+}
+
+export async function importHistoryForUser(uid: IUser['_id'], config: MitelConfig): Promise<void> {
+	const directoryNumber = await getUserDirectoryNumber(uid);
+	if (!directoryNumber) {
+		return;
+	}
+
+	return fetchAndImportHistory({ directoryNumber, uid }, config);
+}

apps/meteor/server/services/call-history/mitel/importHistoryItems.ts

@@ -0,0 +1,18 @@
+import type { IUser } from '@rocket.chat/core-typings';
+import { CallHistory } from '@rocket.chat/models';
+
+import { logger } from '../logger';
+import type { MitelCallItem } from './definition';
+import { convertMitelHistoryItem } from './parse/convertMitelHistoryItem';
+
+export async function importHistoryItems(uid: IUser['_id'], items: MitelCallItem[]): Promise<void> {
+	for (const item of items) {
+		try {
+			const record = convertMitelHistoryItem(item, uid);
+
+			await CallHistory.importHistoryItem(record);
+		} catch (err) {
+			logger.error({ msg: 'Failed to import Call History Item', uid, err });
+		}
+	}
+}