@webitel/api-services 1.0.10 → 1.0.12

package/src/api/clients/backendProfiles/backendProfiles.ts

@@ -0,0 +1,194 @@
+import { getBackendProfileService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	AddItemParams,
+	ApiParams,
+	DeleteItemParams,
+	GetItemParams,
+	PatchItemParams,
+	UpdateItemParams,
+} from '../_shared/types';
+
+/**
+ * File storage backends ("storage profiles" in the admin UI).
+ *
+ * `type` and `properties.region` are returned as the raw backend strings.
+ * Mapping them onto UI enums and region option objects is the caller's job —
+ * those lookups are app-side.
+ */
+const fieldsToSend = [
+	'name',
+	'maxSize',
+	'priority',
+	'properties',
+	'expireDays',
+	'type',
+	'disabled',
+];
+
+const getBackendProfilesList = async (params: ApiParams) => {
+	const defaultObject = {
+		disabled: false,
+		maxSize: 0,
+		expireDays: 0,
+		priority: 0,
+	};
+
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await getBackendProfileService().searchBackendProfile({
+			page,
+			size,
+			// the generated param is `q`; `search` is what the datalist store sends
+			q: search,
+			sort,
+			fields,
+			id,
+		});
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				mergeEach(defaultObject),
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getBackendProfile = async ({ itemId: id }: GetItemParams) => {
+	const defaultObject = {
+		maxSize: 0,
+		expireDays: 0,
+		priority: 0,
+	};
+
+	try {
+		const response = await getBackendProfileService().readBackendProfile(
+			String(id),
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addBackendProfile = async ({ itemInstance }: AddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getBackendProfileService().createBackendProfile(item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateBackendProfile = async ({
+	itemInstance,
+	itemId: id,
+}: UpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getBackendProfileService().updateBackendProfile(
+			String(id),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchBackendProfile = async ({ changes, id }: PatchItemParams) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getBackendProfileService().patchBackendProfile(
+			String(id),
+			body,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteBackendProfile = async ({ id }: DeleteItemParams) => {
+	try {
+		const response = await getBackendProfileService().deleteBackendProfile(
+			String(id),
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getBackendProfilesLookup = (
+	params: Parameters<typeof getBackendProfilesList>[0],
+) =>
+	getBackendProfilesList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+		],
+	});
+
+export const BackendProfilesAPI = {
+	getList: getBackendProfilesList,
+	get: getBackendProfile,
+	add: addBackendProfile,
+	patch: patchBackendProfile,
+	update: updateBackendProfile,
+	delete: deleteBackendProfile,
+	getLookup: getBackendProfilesLookup,
+};

package/src/api/clients/buckets/buckets.ts

@@ -1,10 +1,5 @@
-import { BucketServiceApiFactory } from 'webitel-sdk';
-import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+import { getBucketService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
@@ -22,26 +17,27 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const bucketService = BucketServiceApiFactory(configuration, '', instance);
-
 const getBucketsList = async (params: ApiParams) => {
-	const { page, size, search, sort, fields, id } = applyTransform(params, [
+	const requestParams = applyTransform(params, [
 		merge(getDefaultGetParams()),
 		starToSearch('search'),
+		camelToSnake(),
+		(params) => ({
+			...params,
+			q: params.search,
+		}),
+		sanitize([
+			'page',
+			'size',
+			'q',
+			'sort',
+			'fields',
+			'id',
+		]),
 	]);
 
 	try {
-		const response = await bucketService.searchBucket(
-			page,
-			size,
-			search,
-			sort,
-			fields,
-			id,
-		);
+		const response = await getBucketService().searchBucket(requestParams);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -59,7 +55,7 @@ const getBucketsList = async (params: ApiParams) => {
 
 const getBucket = async ({ itemId: id }: GetItemParams) => {
 	try {
-		const response = await bucketService.readBucket(String(id));
+		const response = await getBucketService().readBucket(String(id));
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -81,7 +77,7 @@ const addBucket = async ({ itemInstance }: AddItemParams) => {
 		camelToSnake(),
 	]);
 	try {
-		const response = await bucketService.createBucket(item);
+		const response = await getBucketService().createBucket(item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -98,7 +94,7 @@ const updateBucket = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 		camelToSnake(),
 	]);
 	try {
-		const response = await bucketService.updateBucket(String(id), item);
+		const response = await getBucketService().updateBucket(String(id), item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -111,7 +107,7 @@ const updateBucket = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 
 const deleteBucket = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await bucketService.deleteBucket(String(id));
+		const response = await getBucketService().deleteBucket(String(id));
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [

package/src/api/clients/callHistory/callAnnotations.ts

@@ -0,0 +1,91 @@
+import { getCallService } from '../../../gen-wire';
+import {
+	applyTransform,
+	camelToSnake,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers';
+import type { ApiParams } from '../_shared/types';
+
+/** Text notes pinned to a timeframe of a historical call. */
+const fieldsToSend = [
+	'note',
+	'startSec',
+	'endSec',
+	'fileId',
+	'callId',
+];
+
+const addCallAnnotation = async ({
+	itemInstance,
+}: {
+	itemInstance: ApiParams;
+}) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getCallService().createCallAnnotation(
+			String(itemInstance.callId),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateCallAnnotation = async ({
+	itemInstance,
+}: {
+	itemInstance: ApiParams;
+}) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getCallService().updateCallAnnotation(
+			String(itemInstance.callId),
+			String(itemInstance.id),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteCallAnnotation = async ({
+	itemInstance,
+}: {
+	itemInstance: ApiParams;
+}) => {
+	try {
+		const response = await getCallService().deleteCallAnnotation(
+			String(itemInstance.callId),
+			String(itemInstance.id),
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const CallAnnotationsAPI = {
+	add: addCallAnnotation,
+	update: updateCallAnnotation,
+	delete: deleteCallAnnotation,
+};

package/src/api/clients/callHistory/callHistory.ts

@@ -8,7 +8,7 @@ import {
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
-import type { ApiParams } from '../_shared/types';
+import type { ApiId, ApiParams } from '../_shared/types';
 
 const getCallHistoryList = async ({
 	options,
@@ -43,22 +43,37 @@ const getCallHistoryList = async ({
 const getCallHistoryListPost = async ({
 	data,
 	options,
+	doNotConvertKeys = [],
+	responseTransformers,
 }: {
 	data: ApiParams;
-	options: ApiParams;
+	options?: ApiParams;
+	/**
+	 * Keys whose contents are user data rather than API fields — `variables`,
+	 * for instance — and must survive both case transformers untouched.
+	 */
+	doNotConvertKeys?: string[];
+	/**
+	 * Replaces the default response pipeline. A CSV export, for one, wants the
+	 * rows left in snake_case.
+	 */
+	responseTransformers?: Parameters<typeof applyTransform>[1];
 }) => {
 	const body = applyTransform(data, [
-		camelToSnake(),
+		camelToSnake(doNotConvertKeys),
 	]);
 	try {
 		const response = await getCallService().searchHistoryCallPost(
 			body,
 			options,
 		);
-		const { items, next } = applyTransform(response.data, [
-			snakeToCamel(),
-			merge(getDefaultGetListResponse()),
-		]);
+		const { items, next } = applyTransform(
+			response.data,
+			responseTransformers ?? [
+				snakeToCamel(doNotConvertKeys),
+				merge(getDefaultGetListResponse()),
+			],
+		);
 		return {
 			items,
 			next,
@@ -70,6 +85,57 @@ const getCallHistoryListPost = async ({
 	}
 };
 
+/**
+ * Aggregation buckets for the history dashboards. The response is returned as
+ * camelCase rows; shaping them into chart series is the caller's job.
+ */
+const aggregateCallHistory = async ({
+	data,
+	doNotConvertKeys = [],
+}: {
+	data: ApiParams;
+	doNotConvertKeys?: string[];
+}) => {
+	try {
+		const response = await getCallService().aggregateHistoryCall(data);
+		return applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+/** Calls the caller back on a missed call. */
+const redialCall = async ({ callId }: { callId: ApiId }) => {
+	try {
+		const response = await getCallService().redialCall(String(callId), {
+			callId: String(callId),
+		});
+		return response.data;
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+/** Drops a missed call out of the agent's missed list. */
+const hideMissedCall = async ({ callId }: { callId: ApiId }) => {
+	try {
+		const response = await getCallService().patchHistoryCall(String(callId), {
+			hide_missed: true,
+		});
+		return response.data;
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
 const getCallHistoryLookup = (
 	params: Parameters<typeof getCallHistoryList>[0],
 ) =>
@@ -86,5 +152,8 @@ const getCallHistoryLookup = (
 export const CallHistoryAPI = {
 	getList: getCallHistoryList,
 	getListPost: getCallHistoryListPost,
+	aggregate: aggregateCallHistory,
+	redial: redialCall,
+	hideMissed: hideMissedCall,
 	getLookup: getCallHistoryLookup,
 };

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

@@ -0,0 +1,50 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const listPriorities = vi.fn(() =>
+	Promise.resolve({
+		data: {},
+	}),
+);
+
+vi.mock('../../../../gen-wire', async (importOriginal) => ({
+	...(await importOriginal<Record<string, unknown>>()),
+	getPriorities: () => ({
+		listPriorities,
+	}),
+}));
+
+const { ListPrioritiesQueryParams } = await import('../../../../gen-wire');
+const { CasePrioritiesAPI } = await import('../casePriorities');
+
+/**
+ * `/cases/priorities` is one of eight endpoints out of 441 whose query params
+ * are camelCase — `src/gen` and `src/gen-wire` agree on `notInSla` /
+ * `inSlaCond`, where every other service is snake. crm passes both from
+ * `opened-sla-condition-popup.vue`, so the client must not convert them.
+ *
+ * This used to run `camelToSnake()` and undo it in the destructure. That was
+ * invisible while the call was positional, where argument names never reached
+ * the wire; as object keys, deleting the redundant conversion would have made
+ * both filters `undefined` with no type error and no failing test.
+ */
+describe('CasePrioritiesAPI.getList', () => {
+	beforeEach(() => listPriorities.mockClear());
+
+	it('leaves notInSla and inSlaCond in camelCase', async () => {
+		await CasePrioritiesAPI.getList({
+			page: 1,
+			size: 10,
+			notInSla: '7',
+			inSlaCond: '3',
+		});
+
+		const [params] = listPriorities.mock.calls[0];
+		expect(params).toMatchObject({
+			notInSla: '7',
+			inSlaCond: '3',
+		});
+		expect(ListPrioritiesQueryParams.strict().safeParse(params).success).toBe(
+			true,
+		);
+	});
+});

package/src/api/clients/casePriorities/casePriorities.ts

@@ -1,10 +1,5 @@
-import { PrioritiesApiFactory } from 'webitel-sdk';
-import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+import { getPriorities } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
@@ -21,11 +16,6 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const priorityService = PrioritiesApiFactory(configuration, '', instance);
-
 const fieldsToSend = [
 	'name',
 	'description',
@@ -33,7 +23,12 @@ const fieldsToSend = [
 ];
 
 const getPrioritiesList = async (params: ApiParams) => {
-	const fieldsToSend = [
+	/*
+	 * This endpoint spells its filters in camelCase — both `src/gen` and
+	 * `src/gen-wire` agree — so no case conversion runs here. The object keys
+	 * below are the wire names.
+	 */
+	const listFieldsToSend = [
 		'page',
 		'size',
 		'q',
@@ -41,29 +36,19 @@ const getPrioritiesList = async (params: ApiParams) => {
 		'fields',
 		'id',
 		'notInSla',
-		'inSla',
 		'inSlaCond',
 	];
-	const {
-		page,
-		size,
-		fields,
-		sort,
-		id,
-		q,
-		not_in_sla: notInSla,
-		in_sla_cond: inSlaCond,
-	} = applyTransform(params, [
-		merge(getDefaultGetParams()),
-		(params) => ({
-			...params,
-			q: params.search,
-		}),
-		sanitize(fieldsToSend),
-		camelToSnake(),
-	]);
+	const { page, size, fields, sort, id, q, notInSla, inSlaCond } =
+		applyTransform(params, [
+			merge(getDefaultGetParams()),
+			(params) => ({
+				...params,
+				q: params.search,
+			}),
+			sanitize(listFieldsToSend),
+		]);
 	try {
-		const response = await priorityService.listPriorities(
+		const response = await getPriorities().listPriorities({
 			page,
 			size,
 			fields,
@@ -72,7 +57,7 @@ const getPrioritiesList = async (params: ApiParams) => {
 			q,
 			notInSla,
 			inSlaCond,
-		);
+		});
 		const { items, next } = applyTransform(response.data, [
 			merge(getDefaultGetListResponse()),
 		]);
@@ -93,10 +78,9 @@ const getPriority = async ({ itemId: id }: GetItemParams) => {
 	};
 
 	try {
-		const response = await priorityService.locatePriority(
-			String(id),
-			fieldsToSend,
-		);
+		const response = await getPriorities().locatePriority(String(id), {
+			fields: fieldsToSend,
+		});
 		return applyTransform(response.data, [
 			snakeToCamel(),
 			itemResponseHandler,
@@ -115,7 +99,7 @@ const addPriority = async ({ itemInstance }: AddItemParams) => {
 	]);
 
 	try {
-		const response = await priorityService.createPriority(item);
+		const response = await getPriorities().createPriority(item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -136,7 +120,7 @@ const updatePriority = async ({
 	]);
 
 	try {
-		const response = await priorityService.updatePriority(String(id), item);
+		const response = await getPriorities().updatePriority(String(id), item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -149,7 +133,7 @@ const updatePriority = async ({
 
 const deletePriority = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await priorityService.deletePriority(String(id));
+		const response = await getPriorities().deletePriority(String(id));
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [