@webitel/api-services 0.0.24 → 0.0.27

package/src/api/clients/caseServiceCatalogs/serviceCatalogs.ts

@@ -0,0 +1,196 @@
+import { CatalogsApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const catalogsService = CatalogsApiFactory(configuration, '', instance);
+
+const fieldsToSend = [
+	'id',
+	'name',
+	'code',
+	'sla',
+	'teams',
+	'skills',
+	'status',
+	'state',
+	'prefix',
+	'close_reason_group',
+	'reason',
+	'description',
+	'services',
+];
+const servicesFieldsToSend = [
+	'id',
+	'name',
+	'group',
+	'assignee',
+	'assignee.name',
+	'description',
+	'code',
+	'prefix',
+	'state',
+	'sla',
+	'root_id',
+	'catalog_id',
+];
+
+const getCatalogsList = async (params) => {
+	const fieldsToSend = [
+		'page',
+		'size',
+		'q',
+		'sort',
+		'fields',
+		'id',
+		'hasSubservices',
+	];
+
+	const { page, size, fields, sort, id, q, has_subservices } = applyTransform(
+		params,
+		[
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+			(params) => ({ ...params, q: params.search }),
+			sanitize(fieldsToSend),
+			camelToSnake(),
+		],
+	);
+	try {
+		const response = await catalogsService.listCatalogs(
+			page,
+			size,
+			[...fields, 'services'],
+			sort,
+			id,
+			q,
+			true,
+			'100', // Implemented depth 100 for load all subservices in one request
+			servicesFieldsToSend,
+			has_subservices,
+		);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [snakeToCamel()]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getCatalog = async ({ itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		return item.catalog;
+	};
+
+	try {
+		const response = await catalogsService.locateCatalog(
+			id,
+			fieldsToSend,
+			servicesFieldsToSend,
+		);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addCatalog = async ({ itemInstance }) => {
+	const fieldsToSend = [
+		'name',
+		'description',
+		'prefix',
+		'code',
+		'state',
+		'sla',
+		'status',
+		'close_reason_group',
+		'teams',
+		'skills',
+	];
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await catalogsService.createCatalog(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateCatalog = async ({ itemInstance, itemId: id }) => {
+	const fieldsToSend = [
+		'name',
+		'description',
+		'prefix',
+		'code',
+		'state',
+		'sla',
+		'status',
+		'close_reason_group',
+		'teams',
+		'skills',
+	];
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await catalogsService.updateCatalog(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchCatalog = async ({ itemInstance, itemId: id }) => {
+	const fieldsToSend = ['name', 'description', 'state'];
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await catalogsService.updateCatalog2(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteCatalog = async ({ id }) => {
+	try {
+		const response = await catalogsService.deleteCatalog(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const ServiceCatalogsAPI = {
+	getList: getCatalogsList,
+	get: getCatalog,
+	add: addCatalog,
+	update: updateCatalog,
+	patch: patchCatalog,
+	delete: deleteCatalog,
+};

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

@@ -0,0 +1,179 @@
+import { ServicesApiFactory, WebitelContactsGroupType } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const servicesService = ServicesApiFactory(configuration, '', instance);
+
+const fieldsToSend = [
+	'name',
+	'code',
+	'sla',
+	'status',
+	'state',
+	'description',
+	'group',
+	'assignee',
+	'services',
+	'root_id',
+	'catalog_id',
+];
+
+const getServicesList = async ({ rootId, ...rest }) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const { page, size, fields, sort, id, q } = applyTransform(rest, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await servicesService.listServices(
+			page,
+			size,
+			sort,
+			id,
+			q,
+			rootId,
+			undefined,
+			fields,
+		);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, []),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getService = async ({ itemId: id }) => {
+	const fieldsToSend = [
+		'name',
+		'code',
+		'sla',
+		'state',
+		'prefix',
+		'group',
+		'assignee',
+		'description',
+		'catalog_id',
+		'root_id',
+	];
+
+	const itemResponseHandler = (item) => {
+		return item.service;
+	};
+
+	try {
+		const response = await servicesService.locateService(id, fieldsToSend);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const preRequestHandler = ({ rootId, catalogId }) => {
+	return (item) => ({
+		...item,
+		assignee:
+			item.group?.type === WebitelContactsGroupType.DYNAMIC
+				? {}
+				: item.assignee,
+		rootId,
+		catalogId,
+	});
+};
+
+const addService = async ({ itemInstance, rootId, catalogId }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler({ rootId, catalogId }),
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await servicesService.createService(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateService = async ({
+	itemInstance,
+	itemId: id,
+	rootId,
+	catalogId,
+}) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler({ rootId, catalogId }),
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await servicesService.updateService(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchService = async ({ changes, id }) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await servicesService.updateService2(id, body);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteService = async ({ id }) => {
+	try {
+		const response = await servicesService.deleteService(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getServicesLookup = async (params) =>
+	getServicesList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const ServicesAPI = {
+	getList: getServicesList,
+	get: getService,
+	add: addService,
+	update: updateService,
+	patch: patchService,
+	delete: deleteService,
+	getLookup: getServicesLookup,
+};

package/src/api/clients/caseSources/caseSources.ts

@@ -0,0 +1,116 @@
+import {
+	createSourceBody,
+	getSources,
+	listSourcesQueryParams,
+	updateSourceBody,
+} from '@webitel/api-services/gen';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers/index';
+
+const sourceService = getSources();
+
+const getSourcesList = async (params) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+		listSourcesQueryParams,
+	);
+
+	const { page, size, fields, sort, id, q, type } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await sourceService.listSources({
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q: q || params.search,
+			type,
+		});
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, []),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getSource = async ({ itemId: id }) => {
+	const itemResponseHandler = (item) => item.source; // TODO wtf??
+
+	try {
+		const response = await sourceService.locateSource(id);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addSource = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(getShallowFieldsToSendFromZodSchema(createSourceBody)),
+		camelToSnake(),
+	]);
+	try {
+		const response = await sourceService.createSource(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateSource = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(getShallowFieldsToSendFromZodSchema(updateSourceBody)),
+	]);
+
+	try {
+		const response = await sourceService.updateSource(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteSource = async ({ id }) => {
+	try {
+		const response = await sourceService.deleteSource(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getLookup = (params) =>
+	getSourcesList({
+		...params,
+		fields: params.fields || ['id', 'name', 'type'],
+	});
+
+export const CaseSourcesAPI = {
+	getList: getSourcesList,
+	get: getSource,
+	add: addSource,
+	update: updateSource,
+	delete: deleteSource,
+	getLookup,
+};

package/src/api/clients/caseStatusConditions/caseStatusConditions.ts

@@ -0,0 +1,163 @@
+import { StatusConditionsApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const statusConditionsService = StatusConditionsApiFactory(
+	configuration,
+	'',
+	instance,
+);
+
+const fieldsToSend = ['name', 'description'];
+
+const getStatusConditionsList = async ({ parentId, ...rest }) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const { page, size, fields, sort, id, q } = applyTransform(rest, [
+		merge(getDefaultGetParams()),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await statusConditionsService.listStatusConditions(
+			parentId,
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q,
+		);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [snakeToCamel()]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getStatusCondition = async ({ parentId, itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		return item.status;
+	};
+
+	try {
+		const response = await statusConditionsService.locateStatusCondition(
+			parentId,
+			id,
+			fieldsToSend,
+		);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateStatusCondition = async ({
+	itemInstance,
+	itemId: id,
+	parentId,
+}) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await statusConditionsService.updateStatusCondition(
+			parentId,
+			id,
+			item,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addStatusCondition = async ({ itemInstance, parentId }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await statusConditionsService.createStatusCondition(
+			parentId,
+			item,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchStatusCondition = async ({ id, parentId, changes }) => {
+	const fieldsToSend = ['name', 'description', 'initial', 'final'];
+	const input = applyTransform(changes, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await statusConditionsService.updateStatusCondition2(
+			parentId,
+			id,
+			input,
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteStatusCondition = async ({ id, parentId }) => {
+	try {
+		const response = await statusConditionsService.deleteStatusCondition(
+			parentId,
+			id,
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getStatusesLookup = (params) =>
+	getStatusConditionsList({
+		...params,
+		parentId: params.parentId,
+		id: params.id,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const CaseStatusConditionsAPI = {
+	getList: getStatusConditionsList,
+	getLookup: getStatusesLookup,
+	get: getStatusCondition,
+	update: updateStatusCondition,
+	patch: patchStatusCondition,
+	delete: deleteStatusCondition,
+	add: addStatusCondition,
+};