@webitel/api-services 26.8.37 → 26.8.39

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/api-services",
-	"version": "26.8.37",
+	"version": "26.8.39",
 	"private": false,
 	"repository": {
 		"type": "git",

package/src/api/clients/agentCalls/__tests__/agentCalls.spec.ts

@@ -0,0 +1,179 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const time = 123;
+
+const searchHistoryCallPost = vi.fn(() =>
+	Promise.resolve({
+		data: {
+			items: [
+				{
+					created_at: time,
+					joined_at: time,
+					duration: 60,
+				},
+			],
+		},
+	}),
+);
+
+vi.mock('../../../../gen-wire', async (importOriginal) => ({
+	...(await importOriginal<Record<string, unknown>>()),
+	getCallService: () => ({
+		searchHistoryCallPost,
+	}),
+}));
+
+const { FormatDateMode } = await import('../../../../enums');
+const { convertDuration } = await import('../../../../scripts');
+const { formatDate } = await import('../../../../utils');
+const { AgentCallsAPI } = await import('../agentCalls');
+
+// Expected output mirrors the source `listHandler`: createdAt -> DATETIME,
+// joinedAt -> TIME, durations via convertDuration, every other field null,
+// files grouped into an (empty) object.
+const expectItems = [
+	{
+		createdAt: formatDate(+time, FormatDateMode.DATETIME),
+		joinedAt: formatDate(+time, FormatDateMode.TIME),
+		duration: convertDuration(60),
+		answeredAt: null,
+		bridgedAt: null,
+		queueBridgedAt: null,
+		leavingAt: null,
+		hangupAt: null,
+		reportingAt: null,
+		holdSec: null,
+		waitSec: null,
+		billSec: null,
+		talkSec: null,
+		reportingSec: null,
+		queueWaitSec: null,
+		queueDurationSec: null,
+		scoreRequired: null,
+		files: {},
+	},
+];
+
+describe('AgentCallsAPI.getList', () => {
+	beforeEach(() => searchHistoryCallPost.mockClear());
+
+	it('correctly processes the response', async () => {
+		const response = await AgentCallsAPI.getList({});
+		expect(searchHistoryCallPost).toHaveBeenCalled();
+		expect(response).toEqual({
+			next: false,
+			items: expectItems,
+		});
+	});
+
+	it('sends the request body in snake_case', async () => {
+		await AgentCallsAPI.getList({
+			userId: '2',
+			queueId: '3',
+			skipParent: true,
+		});
+		const [body] = searchHistoryCallPost.mock.calls.at(-1);
+		expect(Object.keys(body)).toEqual(
+			expect.arrayContaining([
+				'user_id',
+				'queue_id',
+				'skip_parent',
+			]),
+		);
+		expect(body).not.toHaveProperty('userId');
+		expect(body).not.toHaveProperty('queueId');
+		expect(body).not.toHaveProperty('skipParent');
+	});
+
+	// EngineSearchHistoryCallRequest's id-ish fields (user_id, agent_id, ...)
+	// are string[] on the wire — a bare id string trips the backend's proto
+	// parser (400 "unexpected token" on the id's own characters).
+	it('wraps single-value id filters into arrays for the wire', async () => {
+		await AgentCallsAPI.getList({
+			userId: '2',
+			agentId: '3',
+			queueId: '4',
+			teamId: '5',
+			contactId: '6',
+			ownerId: '7',
+			gatewayId: '8',
+			ratedBy: '9',
+		});
+		const [body] = searchHistoryCallPost.mock.calls.at(-1);
+		expect(body.user_id).toEqual([
+			'2',
+		]);
+		expect(body.agent_id).toEqual([
+			'3',
+		]);
+		expect(body.queue_id).toEqual([
+			'4',
+		]);
+		expect(body.team_id).toEqual([
+			'5',
+		]);
+		expect(body.contact_id).toEqual([
+			'6',
+		]);
+		expect(body.owner_id).toEqual([
+			'7',
+		]);
+		expect(body.gateway_id).toEqual([
+			'8',
+		]);
+		expect(body.rated_by).toEqual([
+			'9',
+		]);
+	});
+
+	it('leaves id filters undefined when not provided', async () => {
+		await AgentCallsAPI.getList({});
+		const [body] = searchHistoryCallPost.mock.calls.at(-1);
+		expect(body.user_id).toBeUndefined();
+		expect(body.agent_id).toBeUndefined();
+	});
+
+	it('normalizes a {from,to} createdAt range for the wire', async () => {
+		await AgentCallsAPI.getList({
+			createdAt: {
+				from: 100,
+				to: 200,
+			},
+		});
+		const [body] = searchHistoryCallPost.mock.calls.at(-1);
+		expect(body.created_at).toEqual({
+			from: 100,
+			to: 200,
+		});
+	});
+
+	it('omits created_at when neither from nor to is set', async () => {
+		await AgentCallsAPI.getList({});
+		const [body] = searchHistoryCallPost.mock.calls.at(-1);
+		expect(body.created_at).toBeUndefined();
+	});
+
+	// the rated filter's value field emits a real boolean — rated: false is a
+	// legitimate, deliberate filter value, not "no filter applied"
+	it('sends rated: true as-is', async () => {
+		await AgentCallsAPI.getList({
+			rated: true,
+		});
+		const [body] = searchHistoryCallPost.mock.calls.at(-1);
+		expect(body.rated).toBe(true);
+	});
+
+	it('sends rated: false as-is, not omitted or flipped', async () => {
+		await AgentCallsAPI.getList({
+			rated: false,
+		});
+		const [body] = searchHistoryCallPost.mock.calls.at(-1);
+		expect(body.rated).toBe(false);
+	});
+
+	it('omits rated when the filter is not applied', async () => {
+		await AgentCallsAPI.getList({});
+		const [body] = searchHistoryCallPost.mock.calls.at(-1);
+		expect(body).not.toHaveProperty('rated');
+	});
+});

package/src/api/clients/agentCalls/agentCalls.ts

@@ -0,0 +1,178 @@
+import { FormatDateMode } from '../../../enums';
+import { getCallService } from '../../../gen-wire';
+import { convertDuration, normalizeDatetimeRange } from '../../../scripts';
+import { formatDate } from '../../../utils';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type { ApiParams } from '../_shared/types';
+
+const calcTime = (time?: number | string | null) =>
+	time ? formatDate(+time, FormatDateMode.TIME) : null;
+const calcDuration = (duration?: number | string | null) =>
+	duration ? convertDuration(Number(duration)) : null;
+
+// EngineSearchHistoryCallRequest's id-ish fields (agent_id, queue_id, etc.)
+// are all string[] on the wire, even though the filters/store send a single id.
+const toIdArray = (value: unknown): string[] | undefined => {
+	if (value == null || value === '') return undefined;
+	return Array.isArray(value)
+		? value
+		: [
+				String(value),
+			];
+};
+
+const groupFilesByType = (files?: ApiParams[]) => {
+	if (!files) return {};
+	return files.reduce((acc: Record<string, ApiParams[]>, file: ApiParams) => {
+		acc[file.type] = acc[file.type] || [];
+		acc[file.type].push(file);
+		return acc;
+	}, {});
+};
+
+const listHandler = (items: ApiParams[]) =>
+	items.map((item) => ({
+		...item,
+		createdAt: item.createdAt
+			? formatDate(+item.createdAt, FormatDateMode.DATETIME)
+			: null,
+		answeredAt: calcTime(item.answeredAt),
+		bridgedAt: calcTime(item.bridgedAt),
+		queueBridgedAt: calcTime(item.queueBridgedAt),
+		joinedAt: calcTime(item.joinedAt),
+		leavingAt: calcTime(item.leavingAt),
+		hangupAt: calcTime(item.hangupAt),
+		reportingAt: calcTime(item.reportingAt),
+		duration: calcDuration(item.duration),
+		holdSec: calcDuration(item.holdSec),
+		waitSec: calcDuration(item.waitSec),
+		billSec: calcDuration(item.billSec),
+		talkSec: calcDuration(item.talkSec),
+		reportingSec: calcDuration(item.reportingSec),
+		queueWaitSec: calcDuration(item.queueWaitSec),
+		queueDurationSec: calcDuration(item.queueDurationSec),
+		scoreRequired: item.scoreRequired ? (+item.scoreRequired).toFixed(2) : null,
+		files: groupFilesByType(item.files),
+	}));
+
+/** An agent's own call history, shown on their card's "Calls" tab. */
+const getAgentCallsList = async ({ options, ...params }: ApiParams) => {
+	const defaultParams = {
+		search: '',
+		sort: '-created_at',
+		fields: [],
+		skipParent: true,
+	};
+
+	const normalized = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		merge(defaultParams),
+		starToSearch('search'),
+	]);
+
+	const {
+		page,
+		size,
+		search,
+		sort,
+		fields,
+		createdAt,
+		agentId,
+		userId,
+		rated,
+		ratedBy,
+		direction,
+		directions,
+		hasFile,
+		hasTranscript,
+		queueId,
+		teamId,
+		contactId,
+		domainId,
+		ownerId,
+		gatewayId,
+		number,
+		missed,
+		skipParent,
+	} = normalized;
+
+	const postBody: Record<string, unknown> = {
+		page,
+		size,
+		sort,
+		q: search || undefined,
+		createdAt: normalizeDatetimeRange(createdAt),
+		fields: (fields || []).concat([
+			'id',
+			'files',
+		]),
+		agentId: toIdArray(agentId),
+		userId: toIdArray(userId),
+		queueId: toIdArray(queueId),
+		teamId: toIdArray(teamId),
+		contactId: toIdArray(contactId),
+		ownerId: toIdArray(ownerId),
+		gatewayId: toIdArray(gatewayId),
+		ratedBy: toIdArray(ratedBy),
+		direction,
+		directions,
+		hasFile,
+		hasTranscript,
+		number,
+		missed,
+		domainId,
+		skipParent,
+	};
+	if (rated != null) postBody.rated = rated;
+
+	try {
+		const response = await getCallService().searchHistoryCallPost(
+			applyTransform(postBody, [
+				camelToSnake(),
+			]),
+			options,
+		);
+
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+
+		return {
+			items: applyTransform(items, [
+				listHandler,
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getAgentCallsLookup = (params: ApiParams) =>
+	getAgentCallsList({
+		...params,
+		fields: params?.fields || [
+			'id',
+			'destination',
+			'state',
+			'created_at',
+			'files',
+		],
+		size: params?.size ?? 20,
+	});
+
+export const AgentCallsAPI = {
+	getList: getAgentCallsList,
+	getLookup: getAgentCallsLookup,
+};

package/src/api/clients/agents/agents.ts

@@ -104,7 +104,7 @@ const AGENT_DEFAULTS = {
 	supervisor: [],
 	auditor: [],
 	region: {},
-	progressiveCount: 0,
+	progressiveCount: null,
 	chatCount: 0,
 	taskCount: 0,
 	isSupervisor: false,

package/src/api/clients/index.ts

@@ -1,5 +1,6 @@
 export * from './_shared/generatePermissionsApi';
 export * from './activeCalls/activeCalls';
+export * from './agentCalls/agentCalls';
 export * from './agentPauseCauses/agentPauseCauses';
 export * from './agentSkills/agentSkills';
 export * from './agents/agentAbsence';