@webitel/api-services 1.0.6 → 1.0.8

package/src/api/clients/caseServices/services.ts

@@ -19,13 +19,29 @@ import {
 	starToSearch,
 } from '../../transformers';
 import type {
+	AddItemParams,
 	ApiId,
 	ApiParams,
 	DeleteItemParams,
 	GetItemParams,
 	PatchItemParams,
+	UpdateItemParams,
 } from '../_shared/types';
 
+const preRequestHandler = (item: ApiParams) => {
+	return {
+		...item,
+		state: item.state ?? true,
+		sla_id: item.sla?.id,
+		status_id: item.status?.id,
+		close_reason_id: item.closeReason?.id,
+		team_ids: item.teams?.map((team: ApiParams) => team.id),
+		skill_ids: item.skills?.map((skill: ApiParams) => skill.id),
+		assignee:
+			item.group?.type === ContactsGroupType.Dynamic ? {} : item.assignee,
+	};
+};
+
 const getServicesList = async ({
 	parentId,
 	rootId,
@@ -34,7 +50,7 @@ const getServicesList = async ({
 	parentId?: ApiId;
 	rootId: ApiId;
 } & ApiParams) => {
-	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
 		ListServicesQueryParams,
 	);
 
@@ -45,7 +61,7 @@ const getServicesList = async ({
 			...params,
 			q: params.search,
 		}),
-		sanitizeToWire(fieldsToSend),
+		sanitizeToWire(listFieldsToSend),
 		camelToSnake(),
 	]);
 
@@ -53,11 +69,11 @@ const getServicesList = async ({
 		const response = await getServices().listServices({
 			page,
 			size,
-			fields,
 			sort,
 			id,
 			q,
 			root_id: String(rootId ?? parentId),
+			fields,
 		});
 		const { items, next } = applyTransform(response.data, [
 			merge(getDefaultGetListResponse()),
@@ -75,26 +91,15 @@ const getServicesList = async ({
 	}
 };
 
-const getService = async ({ itemId: id }: GetItemParams) => {
-	const fieldsToSend = [
-		'name',
-		'code',
-		'sla',
-		'state',
-		'prefix',
-		'group',
-		'assignee',
-		'description',
-		'default_priority',
-		'catalog_id',
-		'root_id',
-	];
+const serviceFieldsToSend =
+	getShallowFieldsToSendFromZodSchema(CreateServiceBody);
 
+const getService = async ({ itemId: id }: GetItemParams) => {
 	const itemResponseHandler = (item: ApiParams) => item.service;
 
 	try {
 		const response = await getServices().locateService(String(id), {
-			fields: fieldsToSend,
+			fields: serviceFieldsToSend,
 		});
 		return applyTransform(response.data, [
 			snakeToCamel(),
@@ -107,42 +112,14 @@ const getService = async ({ itemId: id }: GetItemParams) => {
 	}
 };
 
-const preRequestHandler = ({
-	rootId,
-	catalogId,
-}: {
-	rootId: ApiId;
-	catalogId: ApiId;
-}) => {
-	return (item: ApiParams) => ({
-		...item,
-		assignee:
-			item.group?.type === ContactsGroupType.Dynamic ? {} : item.assignee,
-		rootId: rootId ?? item.rootId,
-		catalogId: catalogId ?? item.catalogId,
-	});
-};
-
-const addService = async ({
-	itemInstance,
-	rootId,
-	catalogId,
-}: {
-	itemInstance: ApiParams;
-	rootId: ApiId;
-	catalogId: ApiId;
-}) => {
-	const fieldsToSend = getShallowFieldsToSendFromZodSchema(CreateServiceBody);
+const addFieldsToSend = getShallowFieldsToSendFromZodSchema(CreateServiceBody);
 
+const addService = async ({ itemInstance }: AddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		preRequestHandler({
-			rootId,
-			catalogId,
-		}),
-		sanitizeToWire(fieldsToSend),
+		sanitizeToWire(addFieldsToSend),
+		preRequestHandler,
 		camelToSnake(),
 	]);
-
 	try {
 		const response = await getServices().createService(item);
 		return applyTransform(response.data, [
@@ -155,28 +132,18 @@ const addService = async ({
 	}
 };
 
+const updateFieldsToSend =
+	getShallowFieldsToSendFromZodSchema(UpdateServiceBody);
+
 const updateService = async ({
 	itemInstance,
 	itemId: id,
-	rootId,
-	catalogId,
-}: {
-	itemInstance: ApiParams;
-	itemId: ApiId;
-	rootId: ApiId;
-	catalogId: ApiId;
-}) => {
-	const fieldsToSend = getShallowFieldsToSendFromZodSchema(UpdateServiceBody);
-
+}: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		preRequestHandler({
-			rootId,
-			catalogId,
-		}),
-		sanitizeToWire(fieldsToSend),
+		sanitizeToWire(updateFieldsToSend),
+		preRequestHandler,
 		camelToSnake(),
 	]);
-
 	try {
 		const response = await getServices().updateService(String(id), item);
 		return applyTransform(response.data, [
@@ -189,11 +156,12 @@ const updateService = async ({
 	}
 };
 
-const patchService = async ({ changes, id }: PatchItemParams) => {
-	const fieldsToSend = getShallowFieldsToSendFromZodSchema(UpdateService2Body);
+const patchFieldsToSend =
+	getShallowFieldsToSendFromZodSchema(UpdateService2Body);
 
+const patchService = async ({ changes, id }: PatchItemParams) => {
 	const body = applyTransform(changes, [
-		sanitizeToWire(fieldsToSend),
+		sanitizeToWire(patchFieldsToSend),
 		camelToSnake(),
 	]);
 	try {
@@ -221,9 +189,7 @@ const deleteService = async ({ id }: DeleteItemParams) => {
 	}
 };
 
-const getServicesLookup = async (
-	params: Parameters<typeof getServicesList>[0],
-) =>
+const getServicesLookup = (params: Parameters<typeof getServicesList>[0]) =>
 	getServicesList({
 		...params,
 		fields: params.fields || [

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