@webitel/api-services 0.1.65 → 0.1.66

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/api-services",
-	"version": "0.1.65",
+	"version": "0.1.66",
 	"private": false,
 	"repository": {
 		"type": "git",

package/src/api/clients/contactGroups/contactGroups.ts

@@ -1,10 +1,14 @@
-import { GroupsApiFactory } from 'webitel-sdk';
 import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+	AddContactsToGroupsBody,
+	CreateGroupBody,
+	getGroups,
+	ListGroupsQueryParams,
+	UpdateGroupBody,
+} from '@webitel/api-services/gen';
+import { ContactsGroupType } from '@webitel/api-services/gen/models';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
@@ -25,32 +29,19 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const contactGroupsService = GroupsApiFactory(configuration, '', instance);
-
 const baseUrl = '/contacts/groups';
 
-const fieldsToSend = [
-	'name',
-	'description',
-	'enabled',
-	'type',
-	'default_group',
-];
+const groupFieldsToSend = getShallowFieldsToSendFromZodSchema(UpdateGroupBody);
+
+const appendStaticType = (item: ApiParams) => ({
+	...item,
+	type: item.type ?? ContactsGroupType.Static,
+});
 
 const getContactGroupsList = async (params: ApiParams) => {
-	const fieldsToSend = [
-		'page',
-		'size',
-		'q',
-		'sort',
-		'fields',
-		'type',
-		'enabled',
-		'id',
-	];
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
+		ListGroupsQueryParams,
+	);
 	const defaultObject = {
 		enabled: false,
 	};
@@ -58,26 +49,22 @@ const getContactGroupsList = async (params: ApiParams) => {
 	const { page, size, fields, sort, id, q, name, type, enabled } =
 		applyTransform(params, [
 			merge(getDefaultGetParams()),
-			(params) => ({
-				...params,
-				q: params.search,
-			}),
-			sanitize(fieldsToSend),
+			sanitize(listFieldsToSend),
 			camelToSnake(),
 		]);
 
 	try {
-		const response = await contactGroupsService.listGroups(
+		const response = await getGroups().listGroups({
 			page,
 			size,
 			fields,
 			sort,
 			id,
-			q,
+			q: q || params.search,
 			name,
 			type,
 			enabled,
-		);
+		});
 		const { items, next } = applyTransform(response.data, [
 			merge(getDefaultGetListResponse()),
 		]);
@@ -96,13 +83,10 @@ const getContactGroupsList = async (params: ApiParams) => {
 };
 
 const getContactGroup = async ({ itemId: id }: GetItemParams) => {
-	const itemResponseHandler = (item: ApiParams) => item.group;
+	const itemResponseHandler = (item: { group: unknown }) => item.group;
 
 	try {
-		const response = await contactGroupsService.locateGroup(
-			String(id),
-			fieldsToSend,
-		);
+		const response = await getGroups().locateGroup(String(id));
 		return applyTransform(response.data, [
 			snakeToCamel(),
 			itemResponseHandler,
@@ -115,14 +99,17 @@ const getContactGroup = async ({ itemId: id }: GetItemParams) => {
 };
 
 const addStaticContactGroup = async ({ itemInstance }: AddItemParams) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(CreateGroupBody);
+
 	const item = applyTransform(itemInstance, [
-		camelToSnake(),
 		sanitize(fieldsToSend),
+		camelToSnake(),
 	]);
 	try {
-		const response = await contactGroupsService.createGroup(item);
+		const response = await getGroups().createGroup(item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
+			appendStaticType,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -135,14 +122,25 @@ const addContactsToGroups = async ({
 	contactIds,
 	groupIds,
 }: {
-	contactIds: string[];
-	groupIds: string[];
+	contactIds: ApiId[];
+	groupIds: ApiId[];
 }) => {
-	try {
-		const response = await contactGroupsService.addContactsToGroups({
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+		AddContactsToGroupsBody,
+	);
+
+	const item = applyTransform(
+		{
 			groupIds,
 			contactIds,
-		});
+		},
+		[
+			sanitize(fieldsToSend),
+		],
+	);
+
+	try {
+		const response = await getGroups().addContactsToGroups(item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -158,13 +156,12 @@ const removeContactsFromGroup = async ({
 	contactIds,
 }: {
 	id: ApiId;
-	contactIds: string[];
+	contactIds: ApiId[];
 }) => {
 	try {
-		const response = await contactGroupsService.removeContactsFromGroup(
-			String(id),
-			contactIds,
-		);
+		const response = await getGroups().removeContactsFromGroup(String(id), {
+			contactIds: contactIds.map(String),
+		});
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -178,14 +175,15 @@ const updateStaticContactGroup = async ({
 	itemId: id,
 }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
+		sanitize(groupFieldsToSend),
 		camelToSnake(),
-		sanitize(fieldsToSend),
 	]);
 
 	try {
-		const response = await contactGroupsService.updateGroup(String(id), item);
+		const response = await getGroups().updateGroup(String(id), item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
+			appendStaticType,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -196,14 +194,15 @@ const updateStaticContactGroup = async ({
 
 const patchStaticContactGroup = async ({ id, changes }: PatchItemParams) => {
 	const item = applyTransform(changes, [
+		sanitize(groupFieldsToSend),
 		camelToSnake(),
-		sanitize(fieldsToSend),
 	]);
 
 	try {
-		const response = await contactGroupsService.updateGroup2(String(id), item);
+		const response = await getGroups().updateGroup2(String(id), item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
+			appendStaticType,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -214,7 +213,7 @@ const patchStaticContactGroup = async ({ id, changes }: PatchItemParams) => {
 
 const deleteStaticContactGroup = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await contactGroupsService.deleteGroup(String(id));
+		const response = await getGroups().deleteGroup(String(id));
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [

package/src/api/clients/dynamicConditions/dynamicConditions.ts

@@ -0,0 +1,179 @@
+import {
+	CreateConditionBody,
+	getDynamicConditions,
+	ListConditionsQueryParams,
+	UpdateCondition2Body,
+	UpdateConditionBody,
+} from '@webitel/api-services/gen';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers';
+
+const conditionFieldsToSend =
+	getShallowFieldsToSendFromZodSchema(CreateConditionBody);
+
+const getConditionsList = async ({
+	parentId,
+	...params
+}: {
+	parentId: string;
+	[key: string]: unknown;
+}) => {
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
+		ListConditionsQueryParams,
+	);
+
+	const { page, size, fields, sort, id, q } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		sanitize(listFieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await getDynamicConditions().listConditions(parentId, {
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q: q || params.search,
+		});
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, []),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getCondition = async ({ itemId: id }: { itemId: string }) => {
+	const itemResponseHandler = (item: { condition: unknown }) => item.condition;
+
+	try {
+		const response = await getDynamicConditions().locateCondition(id, {
+			fields: conditionFieldsToSend,
+		});
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addCondition = async ({
+	itemInstance,
+	parentId,
+}: {
+	itemInstance: Record<string, unknown>;
+	parentId: string;
+}) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(conditionFieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await getDynamicConditions().createCondition(
+			parentId,
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateCondition = async ({
+	itemInstance,
+	itemId: id,
+}: {
+	itemInstance: Record<string, unknown>;
+	itemId: string;
+}) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(UpdateConditionBody);
+
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await getDynamicConditions().updateCondition(id, item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchCondition = async ({
+	changes,
+	itemId: id,
+}: {
+	changes: Record<string, unknown>;
+	itemId: string;
+}) => {
+	const fieldsToSend =
+		getShallowFieldsToSendFromZodSchema(UpdateCondition2Body);
+
+	const item = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await getDynamicConditions().updateCondition2(id, item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteCondition = async ({ id }: { id: string }) => {
+	try {
+		const response = await getDynamicConditions().deleteCondition(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const DynamicConditionsAPI = {
+	getList: getConditionsList,
+	get: getCondition,
+	add: addCondition,
+	update: updateCondition,
+	patch: patchCondition,
+	delete: deleteCondition,
+};

package/src/api/clients/dynamicGroups/dynamicGroups.ts

@@ -0,0 +1,191 @@
+import {
+	CreateDynamicGroupBody,
+	getDynamicGroups,
+	ListDynamicGroupsQueryParams,
+	UpdateDynamicGroup2Body,
+	UpdateDynamicGroupBody,
+} from '@webitel/api-services/gen';
+import { ContactsGroupType } from '@webitel/api-services/gen/models';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers';
+
+const dynamicGroupFieldsToSend = getShallowFieldsToSendFromZodSchema(
+	UpdateDynamicGroupBody,
+);
+
+const appendDynamicType = (item: Record<string, unknown>) => ({
+	...item,
+	type: item.type ?? ContactsGroupType.Dynamic,
+});
+
+const getDynamicGroupsList = async (params: Record<string, unknown>) => {
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
+		ListDynamicGroupsQueryParams,
+	);
+
+	const { page, size, fields, sort, id, q, name } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		sanitize(listFieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await getDynamicGroups().listDynamicGroups({
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q,
+			name,
+		});
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, []),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getDynamicGroup = async ({ itemId: id }: { itemId: string }) => {
+	const itemResponseHandler = (item: { group: unknown }) => item.group;
+
+	try {
+		const response = await getDynamicGroups().locateDynamicGroup(id);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+			appendDynamicType,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addDynamicGroup = async ({
+	itemInstance,
+}: {
+	itemInstance: Record<string, unknown>;
+}) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+		CreateDynamicGroupBody,
+	);
+
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await getDynamicGroups().createDynamicGroup(item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			appendDynamicType,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateDynamicGroup = async ({
+	itemInstance,
+	itemId: id,
+}: {
+	itemInstance: Record<string, unknown>;
+	itemId: string;
+}) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(dynamicGroupFieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await getDynamicGroups().updateDynamicGroup(id, item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			appendDynamicType,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchDynamicGroup = async ({
+	changes,
+	itemId: id,
+}: {
+	changes: Record<string, unknown>;
+	itemId: string;
+}) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+		UpdateDynamicGroup2Body,
+	);
+
+	const item = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await getDynamicGroups().updateDynamicGroup2(id, item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			appendDynamicType,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteDynamicGroup = async ({ id }: { id: string }) => {
+	try {
+		const response = await getDynamicGroups().deleteDynamicGroup(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getLookup = (params: Record<string, unknown>) =>
+	getDynamicGroupsList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+		],
+	});
+
+export const DynamicGroupsAPI = {
+	getList: getDynamicGroupsList,
+	get: getDynamicGroup,
+	add: addDynamicGroup,
+	update: updateDynamicGroup,
+	patch: patchDynamicGroup,
+	delete: deleteDynamicGroup,
+	getLookup,
+};

package/src/api/clients/index.ts

@@ -20,6 +20,8 @@ export * from './chatGateways/chatGateways';
 export * from './communications/communications';
 export * from './configurations/configurations';
 export * from './contactGroups/contactGroups';
+export * from './dynamicConditions/dynamicConditions';
+export * from './dynamicGroups/dynamicGroups';
 export * from './emails/emails';
 export * from './fileServices/fileServices';
 export * from './flows/flow';

package/src/validations/contactGroup/contactGroup.validations.ts

@@ -0,0 +1,34 @@
+import type { ContactsGroup } from '@webitel/api-services/gen/models';
+import { ContactsGroupType } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+import {
+	lookupSchema,
+	requiredLookupSchema,
+} from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+const baseSchema = {
+	name: z.string().min(1),
+	description: z.string().optional(),
+	enabled: z.boolean().optional(),
+	type: z.string().optional(),
+};
+
+const staticSchema = z.object<ZodShape<ContactsGroup>>({
+	...baseSchema,
+	defaultGroup: lookupSchema.optional(),
+});
+
+const dynamicSchema = z.object<ZodShape<ContactsGroup>>({
+	...baseSchema,
+	defaultGroup: requiredLookupSchema,
+});
+
+export const contactGroupSchema = z.discriminatedUnion('type', [
+	staticSchema.extend({
+		type: z.literal(ContactsGroupType.Static),
+	}),
+	dynamicSchema.extend({
+		type: z.literal(ContactsGroupType.Dynamic),
+	}),
+]);

package/src/validations/contactGroupCondition/contactGroupCondition.validations.ts

@@ -0,0 +1,15 @@
+import type { ContactsDynamicCondition } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+import {
+	lookupSchema,
+	requiredLookupSchema,
+} from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const contactGroupConditionSchema = z.object<
+	ZodShape<ContactsDynamicCondition>
+>({
+	expression: z.string().min(1),
+	group: requiredLookupSchema,
+	assignee: lookupSchema.optional(),
+});

package/src/validations/index.ts

@@ -1,3 +1,4 @@
+export * from './_shared/lookup.validations';
 export * from './auditForm/auditForm.validations';
 export * from './bucket/bucket.validations';
 export * from './calendar/calendar.validations';
@@ -5,6 +6,8 @@ export * from './casePriority/casePriority.validations';
 export * from './caseSource/caseSource.validations';
 export * from './caseStatus/caseStatus.validations';
 export * from './caseStatusCondition/caseStatusCondition.validations';
+export * from './contactGroup/contactGroup.validations';
+export * from './contactGroupCondition/contactGroupCondition.validations';
 export * from './OAuth/OAuth.validations';
 export * from './onlineSkill/onlineSkill.validations';
 export * from './types';