@webitel/api-services 1.0.6 → 1.0.8

package/src/api/clients/cases/cases.ts

@@ -0,0 +1,360 @@
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { snakeToKebab } from '@webitel/api-services/utils';
+import {
+	CreateCaseBody,
+	getCases,
+	UpdateCase2Body,
+	UpdateCaseBody,
+} from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitizeToWire,
+	snakeToCamel,
+} from '../../transformers';
+import { generatePermissionsApi } from '../_shared/generatePermissionsApi';
+import type {
+	AddItemParams,
+	ApiId,
+	ApiParams,
+	DeleteItemParams,
+	GetItemParams,
+} from '../_shared/types';
+import { FTSServiceAPI } from './_internals/ftsService';
+import { stringifyCaseFilters } from './_internals/stringifyCaseFilters';
+
+const casesService = getCases();
+
+const baseUrl = '/cases';
+
+function transformSourceType(data: ApiParams | ApiParams[]) {
+	if (Array.isArray(data)) {
+		return data.map((item) => {
+			if (item.source?.type) {
+				item.source.type = snakeToKebab(item.source.type.toLowerCase());
+			}
+			return item;
+		});
+	}
+
+	if (data.source?.type) {
+		data.source.type = snakeToKebab(data.source.type.toLowerCase());
+	}
+	return data;
+}
+
+const transformCustomFields = (data: ApiParams) => {
+	if (!data.custom) {
+		data.custom = {};
+	}
+
+	return data;
+};
+
+const checkCustomFields = (data: ApiParams) => {
+	if (!Object.keys(data.custom).length) {
+		delete data.custom;
+	}
+
+	return data;
+};
+
+const getCasesList = async (params: ApiParams) => {
+	let ftsIds: string[] | undefined;
+	const { fts } = params;
+	if (fts) {
+		try {
+			const { items } = await FTSServiceAPI.getList({
+				page: params.page,
+				size: params.size,
+				fts: params.fts,
+				sort: params.sort,
+				objectName: [
+					'cases',
+					'case_comments',
+				],
+			});
+			ftsIds = items.map(({ id }: ApiParams) => id);
+		} catch {
+			// skip error, load cases without fts
+		}
+	}
+
+	const { page, size, q, ids, sort, fields, options, ...filters } =
+		applyTransform(
+			{
+				...params,
+				ids: params.ids || ftsIds,
+			},
+			[
+				merge(getDefaultGetParams()),
+				(params) => ({
+					...params,
+					q: params.search,
+				}),
+			],
+		);
+
+	try {
+		const response = await casesService.searchCases(
+			{
+				page,
+				size,
+				q,
+				ids,
+				sort,
+				fields: [
+					'custom',
+					'priority',
+					'description',
+					'comments',
+					...fields,
+				],
+				filters: stringifyCaseFilters(filters),
+			},
+			options,
+		);
+
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				snakeToCamel(),
+				transformSourceType,
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const caseFieldsToSend = [
+	'etag',
+	'id',
+	'name',
+	'subject',
+	'description',
+	'contact_info',
+	'created_at',
+	'planned_reaction_at',
+	'planned_resolve_at',
+	'status_lookup',
+	'close_reason_lookup',
+	'author',
+	'assignee',
+	'reporter',
+	'impacted',
+	'group',
+	'priority',
+	'source',
+	'status',
+	'close_reason',
+	'close_result',
+	'rating',
+	'rating_comment',
+	'reacted_at',
+	'resolved_at',
+	'sla_condition',
+	'difference_in_reaction',
+	'difference_in_resolve',
+	'sla',
+	'service',
+	'comments',
+	'related_cases',
+	'links',
+	'status_condition',
+	'created_by',
+	'custom',
+];
+
+const getCase = async ({ itemId: id }: GetItemParams) => {
+	try {
+		const response = await casesService.locateCase(String(id), {
+			fields: caseFieldsToSend,
+		});
+		return applyTransform(response.data, [
+			snakeToCamel([
+				'custom',
+			]),
+			transformCustomFields,
+			transformSourceType,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteCase = async ({ id }: DeleteItemParams) => {
+	try {
+		const response = await casesService.deleteCase(String(id));
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateFieldsToSend = getShallowFieldsToSendFromZodSchema(UpdateCaseBody);
+
+const updateCase = async ({ itemInstance }: AddItemParams) => {
+	const { etag } = itemInstance;
+
+	const item = applyTransform(itemInstance, [
+		sanitizeToWire(updateFieldsToSend),
+		camelToSnake([
+			'custom',
+		]),
+		checkCustomFields,
+	]);
+
+	try {
+		const response = await casesService.updateCase(etag, item, {
+			fields: caseFieldsToSend,
+		});
+		return applyTransform(response.data.case, [
+			snakeToCamel([
+				'custom',
+			]),
+			transformCustomFields,
+			transformSourceType,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addFieldsToSend = getShallowFieldsToSendFromZodSchema(CreateCaseBody);
+
+const addCase = async ({ itemInstance }: AddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		sanitizeToWire(addFieldsToSend),
+		camelToSnake([
+			'custom',
+		]),
+	]);
+	try {
+		const response = await casesService.createCase(item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchCase = async ({
+	changes,
+	etag,
+}: {
+	changes: ApiParams;
+	etag: ApiId;
+}) => {
+	const body = applyTransform(changes, [
+		sanitizeToWire(getShallowFieldsToSendFromZodSchema(UpdateCase2Body)),
+		camelToSnake(),
+	]);
+	try {
+		const response = await casesService.updateCase2(String(etag), body, {
+			fields: caseFieldsToSend,
+		});
+		return applyTransform(response.data.case, [
+			snakeToCamel([
+				'custom',
+			]),
+			transformCustomFields,
+			transformSourceType,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const exportCase = async (params: ApiParams) => {
+	const { q, sort, fields, options, format, separator, ids, ...filters } =
+		applyTransform(
+			{
+				...params,
+			},
+			[
+				merge(getDefaultGetParams()),
+				(params) => ({
+					...params,
+					q: params.search,
+				}),
+			],
+		);
+
+	delete filters.page;
+	delete filters.size;
+
+	const exportParams: Record<string, unknown> = {
+		q,
+		sort,
+		fields,
+		format,
+		separator,
+		filters: stringifyCaseFilters(filters),
+	};
+
+	if (ids?.length) {
+		exportParams.ids = ids;
+	}
+
+	try {
+		const response = await casesService.exportCases(exportParams, {
+			...options,
+			responseType: 'blob',
+		});
+
+		return {
+			response,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getCasesLookup = (params: Parameters<typeof getCasesList>[0]) =>
+	getCasesList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+			'subject',
+			'priority',
+		],
+	});
+
+export const CasesAPI = {
+	getList: getCasesList,
+	getLookup: getCasesLookup,
+	get: getCase,
+	delete: deleteCase,
+	update: updateCase,
+	add: addCase,
+	patch: patchCase,
+	exportData: exportCase,
+
+	...generatePermissionsApi(baseUrl),
+};
+
+export { FTSServiceAPI } from './_internals/ftsService';
+export { stringifyCaseFilters } from './_internals/stringifyCaseFilters';

package/src/api/clients/chatMessagesHistory/chatMessagesHistory.ts

@@ -0,0 +1,64 @@
+import { getCasesChatCatalog, getContactsChatCatalog } from '../../../gen-wire';
+import { applyTransform, notify, snakeToCamel } from '../../transformers';
+import type { ApiId, ApiParams } from '../_shared/types';
+
+const mergeChatMessagesData = ({
+	messages,
+	peers,
+}: {
+	messages: ApiParams[];
+	peers: ApiParams[];
+}) => {
+	if (!messages) return [];
+	return messages.map(({ from, ...message }) => {
+		return {
+			...message,
+			peer: from && peers ? peers[from.id - 1] : undefined,
+		};
+	});
+};
+
+const buildGetChatHistory =
+	(
+		getChatHistory: (
+			parentId: string,
+			taskId: string,
+		) => Promise<{
+			data: ApiParams;
+		}>,
+	) =>
+	async ({ parentId, taskId }: { parentId: ApiId; taskId: ApiId }) => {
+		try {
+			const response = await getChatHistory(String(parentId), String(taskId));
+			const { messages, peers } = applyTransform(response.data, [
+				snakeToCamel(),
+			]);
+			return {
+				items: applyTransform(
+					{
+						messages,
+						peers,
+					},
+					[
+						mergeChatMessagesData,
+					],
+				),
+			};
+		} catch (err) {
+			throw applyTransform(err, [
+				notify,
+			]);
+		}
+	};
+
+export const ChatMessagesHistoryAPI = {
+	getContactChatHistory: buildGetChatHistory((contactId, chatId) =>
+		getContactsChatCatalog().contactsChatCatalogGetContactChatHistory(
+			contactId,
+			chatId,
+		),
+	),
+	getCaseChatHistory: buildGetChatHistory((caseId, chatId) =>
+		getCasesChatCatalog().casesChatCatalogGetCaseChatHistory(caseId, chatId),
+	),
+};

package/src/api/clients/configurations/configurations.ts

@@ -1,16 +1,17 @@
-import { SystemSettingServiceApiFactory } from 'webitel-sdk';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
 import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+	CreateSystemSettingBody,
+	getSystemSettingService,
+	SearchAvailableSystemSettingQueryParams,
+	SearchSystemSettingQueryParams,
+} from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
@@ -22,30 +23,30 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const configurationService = SystemSettingServiceApiFactory(
-	configuration,
-	'',
-	instance,
-);
-
 const getList = async (params: ApiParams) => {
-	const { page, size, search, sort, fields, name } = applyTransform(params, [
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
+		SearchSystemSettingQueryParams,
+	);
+
+	const { page, size, fields, sort, name, q } = applyTransform(params, [
 		merge(getDefaultGetParams()),
-		starToSearch('search'),
+		merge({
+			q: params.search,
+		}),
+		sanitizeToWire(listFieldsToSend),
+		starToSearch('q'),
+		camelToSnake(),
 	]);
 
 	try {
-		const response = await configurationService.searchSystemSetting(
+		const response = await getSystemSettingService().searchSystemSetting({
 			page,
 			size,
-			search,
-			sort,
 			fields,
+			sort,
 			name,
-		);
+			q,
+		});
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -63,7 +64,9 @@ const getList = async (params: ApiParams) => {
 
 const get = async ({ itemId: id }: GetItemParams) => {
 	try {
-		const response = await configurationService.readSystemSetting(Number(id));
+		const response = await getSystemSettingService().readSystemSetting(
+			Number(id),
+		);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -74,19 +77,21 @@ const get = async ({ itemId: id }: GetItemParams) => {
 	}
 };
 
+// `value` is a free-form `google.protobuf.Value` on the backend and has no
+// fixed shape, so it's not part of the generated body schema — kept on the
+// allowlist by hand alongside it (mirrors `custom` on contacts).
 const fieldsToSend = [
-	'id',
-	'name',
+	...getShallowFieldsToSendFromZodSchema(CreateSystemSettingBody),
 	'value',
 ];
 
 const add = async ({ itemInstance }: AddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
-		const response = await configurationService.createSystemSetting(item);
+		const response = await getSystemSettingService().createSystemSetting(item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -99,11 +104,11 @@ const add = async ({ itemInstance }: AddItemParams) => {
 
 const update = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
-		const response = await configurationService.updateSystemSetting(
+		const response = await getSystemSettingService().updateSystemSetting(
 			Number(id),
 			item,
 		);
@@ -127,7 +132,9 @@ const getLookup = (params: Parameters<typeof getList>[0]) =>
 
 const deleteItem = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await configurationService.deleteSystemSetting(Number(id));
+		const response = await getSystemSettingService().deleteSystemSetting(
+			Number(id),
+		);
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -137,19 +144,29 @@ const deleteItem = async ({ id }: DeleteItemParams) => {
 };
 
 const getObjectsList = async (params: ApiParams) => {
-	const { page, size, search, sort, fields } = applyTransform(params, [
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
+		SearchAvailableSystemSettingQueryParams,
+	);
+
+	const { page, size, fields, sort, q } = applyTransform(params, [
 		merge(getDefaultGetParams()),
-		starToSearch('search'),
+		merge({
+			q: params.search,
+		}),
+		sanitizeToWire(listFieldsToSend),
+		starToSearch('q'),
+		camelToSnake(),
 	]);
 
 	try {
-		const response = await configurationService.searchAvailableSystemSetting(
-			page,
-			size,
-			search,
-			sort,
-			fields,
-		);
+		const response =
+			await getSystemSettingService().searchAvailableSystemSetting({
+				page,
+				size,
+				fields,
+				sort,
+				q,
+			});
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),

package/src/api/clients/contactCases/contactCases.ts

@@ -0,0 +1,109 @@
+import { snakeToKebab } from '@webitel/api-services/utils';
+import { getCases } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	merge,
+	notify,
+	snakeToCamel,
+} from '../../transformers';
+import type { ApiId, ApiParams } from '../_shared/types';
+import { FTSServiceAPI } from '../cases/_internals/ftsService';
+import { stringifyCaseFilters } from '../cases/_internals/stringifyCaseFilters';
+
+function transformSourceType(data: ApiParams) {
+	if (Array.isArray(data)) {
+		return data.map((item) => {
+			if (item.source?.type) {
+				item.source.type = snakeToKebab(item.source.type.toLowerCase());
+			}
+			return item;
+		});
+	}
+
+	if (data.source?.type) {
+		data.source.type = snakeToKebab(data.source.type.toLowerCase());
+	}
+	return data;
+}
+
+const getContactCasesList = async ({
+	parentId,
+	...params
+}: {
+	parentId: ApiId;
+} & ApiParams) => {
+	let ftsIds: Array<string | number> | undefined;
+	const { fts } = params;
+	if (fts) {
+		try {
+			const { items } = await FTSServiceAPI.getList({
+				page: params.page,
+				size: params.size,
+				fts: params.fts,
+				sort: params.sort,
+				objectName: [
+					'cases',
+					'case_comments',
+				],
+			});
+			ftsIds = items.map(({ id }: ApiParams) => id);
+		} catch {
+			// skip error, load cases without fts
+		}
+	}
+
+	/* everything left over after pulling out the technical query params is a
+	 * filter, keyed by the (camelCase) filter names stringifyCaseFilters expects */
+	const { page, size, q, ids, sort, fields, ...filters } = applyTransform(
+		{
+			...params,
+			ids: params.ids || ftsIds,
+		},
+		[
+			merge(getDefaultGetParams()),
+			(params) => ({
+				...params,
+				q: params.search,
+			}),
+		],
+	);
+
+	try {
+		const response = await getCases().searchCases2(String(parentId), {
+			page,
+			size,
+			q,
+			ids,
+			sort,
+			fields: [
+				...(fields || []),
+				'etag',
+				'id',
+				'custom',
+			],
+			filters: stringifyCaseFilters(filters),
+		});
+
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				snakeToCamel([
+					'custom',
+				]),
+				transformSourceType,
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const ContactCasesAPI = {
+	getList: getContactCasesList,
+};