@webitel/api-services 1.0.6 → 1.0.7

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

@@ -0,0 +1,67 @@
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { getFtsservice, SearchQueryParams } from '../../../../gen-wire';
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+} from '../../../defaults';
+import {
+	applyTransform,
+	merge,
+	notify,
+	sanitizeToWire,
+	snakeToCamel,
+} from '../../../transformers';
+import type { ApiParams } from '../../_shared/types';
+
+const getSearchList = async (params: ApiParams) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(SearchQueryParams);
+
+	const {
+		page,
+		size,
+		q,
+		sort,
+		fields,
+		options,
+		object_name: objectName,
+	} = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		(params) => ({
+			...params,
+			q: params.fts,
+		}),
+		sanitizeToWire(fieldsToSend),
+	]);
+
+	try {
+		const response = await getFtsservice().search(
+			{
+				page,
+				size,
+				q,
+				sort,
+				fields,
+				object_name: objectName,
+			},
+			options,
+		);
+
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				snakeToCamel(),
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const FTSServiceAPI = {
+	getList: getSearchList,
+};

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

@@ -0,0 +1,156 @@
+import { isObject } from 'lodash-es';
+import { RelativeDatetimeValue } from '../../../../enums';
+import {
+	isRelativeDatetimeValue,
+	normalizeToTimestamp,
+} from '../../../../scripts';
+import type { ApiParams } from '../../_shared/types';
+
+// filter values are heterogeneous (string, number, object, array) — not worth
+// modeling per filter key
+type FilterTransformer = (
+	// biome-ignore lint/suspicious/noExplicitAny: see comment above
+	value: any,
+	key: string,
+) => string | string[] | undefined;
+
+const filterTransformersMap: Record<string, FilterTransformer> = {
+	createdAt: (createdAt) => {
+		const arr = [];
+		if (!createdAt) {
+			arr.push(
+				`created_at.from=${normalizeToTimestamp(RelativeDatetimeValue.Today, {
+					round: 'start',
+				})}`,
+			);
+		} else {
+			if (typeof createdAt === 'string') {
+				arr.push(
+					`created_at.from=${normalizeToTimestamp(createdAt, {
+						round: 'start',
+					})}`,
+					`created_at.to=${normalizeToTimestamp(createdAt, {
+						round: 'end',
+					})}`,
+				);
+			} else {
+				if (createdAt.from) arr.push(`created_at.from=${createdAt.from}`);
+				if (createdAt.to) arr.push(`created_at.to=${createdAt.to}`);
+			}
+		}
+		return arr;
+	},
+	status: (value) => `status_condition=${value.conditions}`,
+	source: (value) => `source=${value}`,
+	author: (value) => `created_by=${value}`,
+	reporter: (value) => `reporter=${value}`,
+	impacted: (value) => `impacted=${value}`,
+	assignee: (value) =>
+		value.unassigned
+			? `assignee=${value.list},${null}`
+			: `assignee=${value.list}`,
+	contactGroup: (value) =>
+		value.unassigned ? `group=${value.list},${null}` : `group=${value.list}`,
+	priority: (value) => `priority=${value}`,
+	closeReasonGroups: (value) => `close_reason=${value.conditions}`,
+	rating: (value) => {
+		const arr = [];
+		if (value.from) arr.push(`rating.from=${value.from}`);
+		if (value.to) arr.push(`rating.to=${value.to}`);
+		return arr;
+	},
+	service: (value) => `service=${value}`,
+	sla: (value) => `sla=${value}`,
+	slaCondition: (value) => `sla_condition=${value.conditions}`,
+	reactionTime: (value) => {
+		const arr = [];
+		if (value.from) arr.push(`planned_reaction_at.from=${value.from}`);
+		if (value.to) arr.push(`planned_reaction_at.to=${value.to}`);
+		return arr;
+	},
+	resolutionTime: (value) => {
+		const arr = [];
+		if (value.from) arr.push(`planned_resolve_at.from=${value.from}`);
+		if (value.to) arr.push(`planned_resolve_at.to=${value.to}`);
+		return arr;
+	},
+	actualReactionTime: (value) => {
+		const arr = [];
+		if (value.from) arr.push(`reacted_at.from=${value.from}`);
+		if (value.to) arr.push(`reacted_at.to=${value.to}`);
+		return arr;
+	},
+	actualResolutionTime: (value) => {
+		const arr = [];
+		if (value.from) arr.push(`resolved_at.from=${value.from}`);
+		if (value.to) arr.push(`resolved_at.to=${value.to}`);
+		return arr;
+	},
+	hasAttachment: (value) => `attachments=${value}`,
+	others: (value, key) => {
+		const makeArrWithStringValuesFromObjectValue = (
+			value: ApiParams,
+			key: string,
+		) => {
+			return Object.entries(value).map(
+				([propKey, propValue]) => `${key}.${propKey}=${propValue}`,
+			);
+		};
+
+		/* then value is magic datetime string */
+		if (isRelativeDatetimeValue(value)) {
+			const normalizedValue = {
+				from: normalizeToTimestamp(value, {
+					round: 'start',
+				}),
+				to: normalizeToTimestamp(value, {
+					round: 'end',
+				}),
+			};
+			return makeArrWithStringValuesFromObjectValue(normalizedValue, key);
+		}
+
+		/**
+		 * @author @dlohvinov
+		 * if..., then assume its a datetime
+		 */
+		if (value?.from || value?.to) {
+			const normalizedValue: {
+				from?: number;
+				to?: number;
+			} = {};
+
+			if (value.from) {
+				normalizedValue.from = normalizeToTimestamp(value.from);
+			}
+
+			if (value.to) {
+				normalizedValue.to = normalizeToTimestamp(value.to);
+			}
+
+			return makeArrWithStringValuesFromObjectValue(normalizedValue, key);
+		}
+
+		if (!isObject(value) || Array.isArray(value)) return `${key}=${value}`;
+
+		return makeArrWithStringValuesFromObjectValue(value, key);
+	},
+};
+
+export const stringifyCaseFilters = (filters: ApiParams) => {
+	const result: string[] = [];
+
+	for (const [key, value] of Object.entries(filters)) {
+		const transformer =
+			filterTransformersMap[key] || filterTransformersMap.others;
+
+		const strValue = transformer(value, key);
+
+		if (value != null && strValue) {
+			if (Array.isArray(strValue)) {
+				result.push(...strValue);
+			} else result.push(strValue);
+		}
+	}
+	return result;
+};

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),
+	),
+};