@webitel/api-services 26.8.71 → 26.8.73

package/package.json

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

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

@@ -129,3 +129,23 @@ describe('FileServicesAPI.getListByCall', () => {
 		});
 	});
 });
+
+describe('FileServicesAPI.getScreenRecordingsByCall', () => {
+	it('sends start_at range filters for call screen recordings', async () => {
+		await FileServicesAPI.getScreenRecordingsByCall({
+			callId: 'call-1',
+			startAtFrom: '1700000000000',
+			startAtTo: '1700000009999',
+			type: 'SCREENSHARING',
+			channel: 'SCREENRECORDING',
+		});
+
+		expect(captured[0].url).toBe('/storage/call/call-1');
+		expect(sentParams()).toMatchObject({
+			'start_at.from': '1700000000000',
+			'start_at.to': '1700000009999',
+			type: 'SCREENSHARING',
+			channel: 'SCREENRECORDING',
+		});
+	});
+});

package/src/api/clients/fileServices/fileServices.ts

@@ -2,6 +2,7 @@ import type {
 	SearchFilesByCallParams,
 	SearchFilesParams,
 	SearchScreenRecordingsByAgentParams,
+	SearchScreenRecordingsByCallParams,
 	SearchScreenRecordingsParams,
 } from '@webitel/api-services/gen/models';
 import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
@@ -10,12 +11,14 @@ import {
 	SearchFilesByCallQueryParams,
 	SearchFilesQueryParams,
 	SearchScreenRecordingsByAgentQueryParams,
+	SearchScreenRecordingsByCallQueryParams,
 	SearchScreenRecordingsQueryParams,
 } from '../../../gen-wire';
 import type {
 	SearchFilesByCallParams as SearchFilesByCallWireParams,
 	SearchFilesParams as SearchFilesWireParams,
 	SearchScreenRecordingsByAgentParams as SearchScreenRecordingsByAgentWireParams,
+	SearchScreenRecordingsByCallParams as SearchScreenRecordingsByCallWireParams,
 	SearchScreenRecordingsParams as SearchScreenRecordingsWireParams,
 } from '../../../gen-wire/_models';
 import type {
@@ -222,6 +225,55 @@ const getScreenRecordingsByAgent = async (
 	}
 };
 
+const getScreenRecordingsByCall = async (
+	params: SearchScreenRecordingsByCallParams & {
+		callId: ApiId;
+		search?: string;
+	},
+) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+		SearchScreenRecordingsByCallQueryParams,
+	);
+
+	const requestParams = applyTransform<SearchScreenRecordingsByCallWireParams>(
+		params,
+		[
+			merge(getDefaultGetParams()),
+			sanitizeToWire(fieldsToSend),
+			camelToSnake(),
+		],
+	);
+
+	try {
+		const response = await getFileService().searchScreenRecordingsByCall(
+			String(params.callId),
+			{
+				...requestParams,
+				q: requestParams.q || params.search,
+				fields: [
+					'id',
+					'view_name',
+					'mime_type',
+					...(requestParams.fields ?? []),
+				],
+			},
+		);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				snakeToCamel(),
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
 const deleteScreenRecordingsByAgent = async ({
 	agentId,
 	id,
@@ -295,6 +347,7 @@ export const FileServicesAPI = {
 	getScreenRecordingsByUser,
 	deleteScreenRecordingsByUser,
 	getScreenRecordingsByAgent,
+	getScreenRecordingsByCall,
 	deleteScreenRecordingsByAgent,
 	getListByCall: getFilesListByCall,
 };

package/src/api/clients/outboundResources/outboundResources.ts

@@ -1,5 +1,11 @@
-import deepCopy from 'deep-copy';
-import { getOutboundResourceService } from '../../../gen-wire';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import {
+	CreateOutboundResourceBody,
+	getOutboundResourceService,
+	PatchOutboundResourceBody,
+	SearchOutboundResourceQueryParams,
+	UpdateOutboundResourceBody,
+} from '../../../gen-wire';
 import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
@@ -7,7 +13,7 @@ import {
 	merge,
 	mergeEach,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
@@ -23,54 +29,28 @@ import type {
 
 const baseUrl = '/call_center/resources';
 
-const fieldsToSend = [
-	'limit',
-	'enabled',
-	'rps',
-	'maxSuccessivelyErrors',
-	'name',
-	'errorIds',
-	'display',
-	'description',
-	'resourceId',
-	'gateway',
-	'patterns',
-	'failureDialDelay',
-	'parameters',
-];
-
-/*
- * The form binds `maxErrors` / `cps`, the API expects
- * `maxSuccessivelyErrors` / `rps`. `getResource` maps them back.
- */
-const preRequestHandler = (item: ApiParams) => {
-	const copy = deepCopy(item);
-	copy.maxSuccessivelyErrors = copy.maxErrors;
-	copy.rps = copy.cps;
-	return copy;
-};
-
-const getResourcesList = async (params: ApiParams) => {
+const getOutboundResourcesList = async (params: ApiParams) => {
 	const defaultObject = {
 		gateway: null,
 		enabled: false,
 	};
 
-	const { page, size, search, sort, fields, id } = applyTransform(params, [
+	const requestParams = applyTransform(params, [
 		merge(getDefaultGetParams()),
 		starToSearch('search'),
+		(params: ApiParams) => ({
+			...params,
+			q: params.q ?? params.search,
+		}),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(SearchOutboundResourceQueryParams),
+		),
+		camelToSnake(),
 	]);
 
 	try {
-		const response = await getOutboundResourceService().searchOutboundResource({
-			page,
-			size,
-			// the generated param is `q`; `search` is what the datalist store sends
-			q: search,
-			sort,
-			fields,
-			id,
-		});
+		const response =
+			await getOutboundResourceService().searchOutboundResource(requestParams);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -88,34 +68,14 @@ const getResourcesList = async (params: ApiParams) => {
 	}
 };
 
-const getResource = async ({ itemId: id }: GetItemParams) => {
+const getOutboundResource = async ({ itemId: id }: GetItemParams) => {
 	const defaultObject = {
-		name: '',
-		gateway: {},
-		rps: 0,
-		limit: 0,
-		description: '',
-		maxSuccessivelyErrors: 0,
-		errorIds: [],
-		patterns: [],
-		failureDialDelay: 0,
 		parameters: {
 			cidType: '',
 			ignoreEarlyMedia: '',
 		},
 	};
 
-	const responseHandler = (response: ApiParams) => {
-		const copy = deepCopy(response);
-		copy.maxErrors = copy.maxSuccessivelyErrors;
-		copy.cps = copy.rps;
-		copy.parameters = {
-			...defaultObject.parameters,
-			...copy.parameters,
-		};
-		return copy;
-	};
-
 	try {
 		const response = await getOutboundResourceService().readOutboundResource(
 			String(id),
@@ -123,7 +83,6 @@ const getResource = async ({ itemId: id }: GetItemParams) => {
 		return applyTransform(response.data, [
 			snakeToCamel(),
 			merge(defaultObject),
-			responseHandler,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -132,10 +91,11 @@ const getResource = async ({ itemId: id }: GetItemParams) => {
 	}
 };
 
-const addResource = async ({ itemInstance }: AddItemParams) => {
+const addOutboundResource = async ({ itemInstance }: AddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		preRequestHandler,
-		sanitize(fieldsToSend),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(CreateOutboundResourceBody),
+		),
 		camelToSnake(),
 	]);
 	try {
@@ -151,13 +111,14 @@ const addResource = async ({ itemInstance }: AddItemParams) => {
 	}
 };
 
-const updateResource = async ({
+const updateOutboundResource = async ({
 	itemInstance,
 	itemId: id,
 }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		preRequestHandler,
-		sanitize(fieldsToSend),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(UpdateOutboundResourceBody),
+		),
 		camelToSnake(),
 	]);
 	try {
@@ -175,9 +136,11 @@ const updateResource = async ({
 	}
 };
 
-const patchResource = async ({ changes, id }: PatchItemParams) => {
+const patchOutboundResource = async ({ changes, id }: PatchItemParams) => {
 	const body = applyTransform(changes, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(PatchOutboundResourceBody),
+		),
 		camelToSnake(),
 	]);
 	try {
@@ -195,7 +158,7 @@ const patchResource = async ({ changes, id }: PatchItemParams) => {
 	}
 };
 
-const deleteResource = async ({ id }: DeleteItemParams) => {
+const deleteOutboundResource = async ({ id }: DeleteItemParams) => {
 	try {
 		const response = await getOutboundResourceService().deleteOutboundResource(
 			String(id),
@@ -208,8 +171,8 @@ const deleteResource = async ({ id }: DeleteItemParams) => {
 	}
 };
 
-const getResourcesLookup = (params: Parameters<typeof getResourcesList>[0]) =>
-	getResourcesList({
+const getOutboundResourcesLookup = (params: ApiParams) =>
+	getOutboundResourcesList({
 		...params,
 		fields: params.fields || [
 			'id',
@@ -218,13 +181,13 @@ const getResourcesLookup = (params: Parameters<typeof getResourcesList>[0]) =>
 	});
 
 export const OutboundResourcesAPI = {
-	getList: getResourcesList,
-	get: getResource,
-	add: addResource,
-	patch: patchResource,
-	update: updateResource,
-	delete: deleteResource,
-	getLookup: getResourcesLookup,
+	getList: getOutboundResourcesList,
+	get: getOutboundResource,
+	add: addOutboundResource,
+	update: updateOutboundResource,
+	patch: patchOutboundResource,
+	delete: deleteOutboundResource,
+	getLookup: getOutboundResourcesLookup,
 
 	...generatePermissionsApi(baseUrl),
 };

package/src/api/clients/outboundResources/resourceDisplays.ts

@@ -1,11 +1,24 @@
-import { getOutboundResourceService } from '../../../gen-wire';
-import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import type { AxiosError } from 'axios';
+import type { Composer } from 'vue-i18n';
+import { config } from '../../../config/config';
+import {
+	CreateOutboundResourceDisplayBody,
+	getOutboundResourceService,
+	SearchOutboundResourceDisplayQueryParams,
+	UpdateOutboundResourceDisplayBody,
+} from '../../../gen-wire';
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+} from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
@@ -18,38 +31,30 @@ import type {
 	NestedUpdateItemParams,
 } from '../_shared/types';
 
-const fieldsToSend = [
-	'display',
-	'resourceId',
-];
-
-const preRequestHandler = (parentId: ApiId) => (item: ApiParams) => ({
-	...item,
-	resourceId: parentId,
-});
+const instance = getDefaultInstance();
 
 const getResourceDisplaysList = async (params: ApiParams) => {
-	const { page, size, search, sort, fields, id, parentId } = applyTransform(
-		params,
-		[
-			merge(getDefaultGetParams()),
-			starToSearch('search'),
-		],
-	);
+	const { parentId, ...rest } = params;
+	const requestParams = applyTransform(rest, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		(params: ApiParams) => ({
+			...params,
+			q: params.q ?? params.search,
+		}),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(
+				SearchOutboundResourceDisplayQueryParams,
+			),
+		),
+		camelToSnake(),
+	]);
 
 	try {
 		const response =
 			await getOutboundResourceService().searchOutboundResourceDisplay(
 				String(parentId),
-				{
-					page,
-					size,
-					// the generated param is `q`; `search` is what the datalist store sends
-					q: search,
-					sort,
-					fields,
-					id,
-				},
+				requestParams,
 			);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
@@ -91,8 +96,9 @@ const addResourceDisplay = async ({
 	itemInstance,
 }: NestedAddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		preRequestHandler(parentId),
-		sanitize(fieldsToSend),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(CreateOutboundResourceDisplayBody),
+		),
 		camelToSnake(),
 	]);
 	try {
@@ -117,8 +123,9 @@ const updateResourceDisplay = async ({
 	itemId: id,
 }: NestedUpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		preRequestHandler(parentId),
-		sanitize(fieldsToSend),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(UpdateOutboundResourceDisplayBody),
+		),
 		camelToSnake(),
 	]);
 	try {
@@ -156,10 +163,77 @@ const deleteResourceDisplay = async ({
 	}
 };
 
+/**
+ * [Claude] Invalid numbers in an uploaded file come back with an id that starts
+ * with `cc_outbound_resource.validatePhoneNumber`. Only the prefix is known, so
+ * `translateError`, which looks the translation up by the exact id, does not fit.
+ *
+ * [WTEL-10579](https://webitel.atlassian.net/browse/WTEL-10579)
+ */
+const translatePhoneNumberError = (
+	err: AxiosError<{
+		id?: string;
+		translation?: string;
+	}>,
+) => {
+	const data = err.response?.data;
+	if (
+		data?.id?.startsWith('cc_outbound_resource.validatePhoneNumber') &&
+		config.i18n?.global
+	) {
+		data.translation = (config.i18n.global as Composer).t(
+			'backendErrors.ccOutboundResource.validatePhoneNumber',
+		);
+	}
+	return err;
+};
+
+/**
+ * [Claude] Bulk number import from a csv file: the file itself is sent, and the
+ * backend parses it and validates the numbers. `POST /displays/:id` is not in
+ * the OpenAPI spec, so there is no generated method for it — the request goes
+ * through the default instance instead.
+ *
+ * [WTEL-10579](https://webitel.atlassian.net/browse/WTEL-10579)
+ */
+const uploadResourceDisplays = async ({
+	parentId,
+	file,
+	delimiter,
+	map,
+}: {
+	parentId: ApiId;
+	file: File;
+	delimiter: string;
+	map: string;
+}) => {
+	const formData = new FormData();
+	formData.append('file', file);
+	formData.append('delimiter', delimiter);
+	formData.append('map', map);
+
+	try {
+		const response = await instance.post(`/displays/${parentId}`, formData, {
+			headers: {
+				'Content-Type': 'multipart/form-data',
+			},
+		});
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			translatePhoneNumberError,
+			notify,
+		]);
+	}
+};
+
 export const ResourceDisplaysAPI = {
 	getList: getResourceDisplaysList,
 	get: getResourceDisplay,
 	add: addResourceDisplay,
 	update: updateResourceDisplay,
 	delete: deleteResourceDisplay,
+	upload: uploadResourceDisplays,
 };

package/src/api/clients/pdfServices/__tests__/downloadCallScreenrecordingArchive.spec.ts

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const downloadCallScreenrecordingArchive = vi.fn();
+
+vi.mock('../../../../gen-wire', async () => {
+	const actual = await vi.importActual<typeof import('../../../../gen-wire')>(
+		'../../../../gen-wire',
+	);
+
+	return {
+		...actual,
+		getPdfService: () => ({
+			downloadCallScreenrecordingArchive,
+		}),
+	};
+});
+
+const { PdfServicesAPI } = await import('../pdfServices');
+
+describe('PdfServicesAPI.downloadCallScreenrecordingArchive', () => {
+	beforeEach(() => {
+		downloadCallScreenrecordingArchive.mockReset();
+	});
+
+	it('requests a blob archive with snake_case query params', async () => {
+		const response = {
+			data: new Blob([
+				'zip',
+			]),
+		};
+		downloadCallScreenrecordingArchive.mockResolvedValue(response);
+
+		await expect(
+			PdfServicesAPI.downloadCallScreenrecordingArchive({
+				callId: 'call-1',
+				fileIds: [
+					'123',
+					'456',
+				],
+				from: '1700000000000',
+				to: '170000000100000',
+			}),
+		).resolves.toBe(response);
+
+		expect(downloadCallScreenrecordingArchive).toHaveBeenCalledWith(
+			'call-1',
+			{
+				file_ids: [
+					'123',
+					'456',
+				],
+				from: '1700000000000',
+				to: '170000000100000',
+			},
+			{
+				responseType: 'blob',
+			},
+		);
+	});
+});

package/src/api/clients/pdfServices/pdfServices.ts

@@ -1,4 +1,5 @@
 import type {
+	DownloadCallScreenrecordingArchiveParams,
 	ListCallExportsParams,
 	ListScreenrecordingExportsParams,
 } from '@webitel/api-services/gen/models';
@@ -7,6 +8,7 @@ import {
 	CreateCallExportBody,
 	CreateScreenrecordingExportBody,
 	DownloadCallArchiveQueryParams,
+	DownloadCallScreenrecordingArchiveQueryParams,
 	DownloadScreenrecordingArchiveQueryParams,
 	DownloadScreenshotArchiveQueryParams,
 	getPdfService,
@@ -211,6 +213,45 @@ const downloadCallArchive = async ({
 	}
 };
 
+const downloadCallScreenrecordingArchive = async ({
+	callId,
+	fileIds,
+	from,
+	to,
+}: DownloadCallScreenrecordingArchiveParams & {
+	callId: ApiId;
+}) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+		DownloadCallScreenrecordingArchiveQueryParams,
+	);
+
+	const params = applyTransform(
+		{
+			fileIds,
+			from,
+			to,
+		},
+		[
+			sanitizeToWire(fieldsToSend),
+			camelToSnake(),
+		],
+	);
+
+	try {
+		return await getPdfService().downloadCallScreenrecordingArchive(
+			String(callId),
+			params,
+			{
+				responseType: 'blob',
+			},
+		);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
 const downloadScreenrecordingArchive = async ({
 	agentId,
 	fileIds,
@@ -314,6 +355,7 @@ export const PdfServicesAPI = {
 	createCallExport,
 	listCallExports,
 	downloadCallArchive,
+	downloadCallScreenrecordingArchive,
 	downloadScreenrecordingArchive,
 	downloadScreenshotArchive,
 	delete: deleteExport,

package/src/enums/ResourceCidType/ResourceCidType.ts

@@ -0,0 +1,8 @@
+export const ResourceCidType = {
+	None: 'none',
+	Rpid: 'rpid',
+	Pid: 'pid',
+} as const;
+
+export type ResourceCidType =
+	(typeof ResourceCidType)[keyof typeof ResourceCidType];

package/src/enums/ResourceIgnoreEarlyMedia/ResourceIgnoreEarlyMedia.ts

@@ -0,0 +1,9 @@
+export const ResourceIgnoreEarlyMedia = {
+	True: 'true',
+	False: 'false',
+	Consume: 'consume',
+	RingReady: 'ring_ready',
+} as const;
+
+export type ResourceIgnoreEarlyMedia =
+	(typeof ResourceIgnoreEarlyMedia)[keyof typeof ResourceIgnoreEarlyMedia];

package/src/enums/index.ts

@@ -12,6 +12,8 @@ import {
 } from './QueueStrategy/QueueStrategy';
 import { QueueType, QueueTypeName } from './QueueType/QueueType';
 import { RelativeDatetimeValue } from './RelativeDatetimeValue/RelativeDatetimeValue';
+import { ResourceCidType } from './ResourceCidType/ResourceCidType';
+import { ResourceIgnoreEarlyMedia } from './ResourceIgnoreEarlyMedia/ResourceIgnoreEarlyMedia';
 import { TimeBaseScore } from './TimeBaseScore/TimeBaseScore';
 import { TypesResourceStrategy } from './TypesResourceStrategy/TypesResourceStrategy';
 import { UrlProtocol } from './UrlProtocol/UrlProtocol';
@@ -31,6 +33,8 @@ export {
 	QueueType,
 	QueueTypeName,
 	RelativeDatetimeValue,
+	ResourceCidType,
+	ResourceIgnoreEarlyMedia,
 	TimeBaseScore,
 	TypesResourceStrategy,
 	UrlProtocol,

package/src/locale/en/en.ts

@@ -2,6 +2,10 @@ import type { MessageContext } from 'vue-i18n';
 
 export default {
 	backendErrors: {
+		ccOutboundResource: {
+			validatePhoneNumber: ({ linked }: MessageContext) =>
+				`File contains invalid numbers. ${linked('validation.phoneNumberSymbolsValidator')}`,
+		},
 		contacts: {
 			search: {
 				filters: {