@webitel/api-services 0.1.68 → 0.1.70

package/src/api/clients/queues/queueSkills.ts

@@ -0,0 +1,183 @@
+import { getQueueSkillService } from '@webitel/api-services/gen';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { queueSkillSchema } from '@webitel/api-services/validations';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	ApiId,
+	ApiParams,
+	NestedAddItemParams,
+	NestedDeleteItemParams,
+	NestedGetItemParams,
+	NestedPatchItemParams,
+	NestedUpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	...getShallowFieldsToSendFromZodSchema(queueSkillSchema),
+	// injected by preRequestHandler; not part of the form, so not in the schema
+	'queueId',
+];
+
+const preRequestHandler = (parentId: ApiId) => (item: ApiParams) => ({
+	...item,
+	queueId: parentId,
+});
+
+const getQueueSkillsList = async (params: ApiParams) => {
+	const { page, size, search, sort, fields, id, parentId, skillId } =
+		applyTransform(params, [
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+		]);
+
+	try {
+		const response = await getQueueSkillService().searchQueueSkill(
+			Number(parentId),
+			{
+				page,
+				size,
+				// the generated param is `q`; `search` is what the datalist store sends
+				q: search,
+				sort,
+				fields,
+				id,
+				skillId,
+			},
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getQueueSkill = async ({ parentId, itemId: id }: NestedGetItemParams) => {
+	try {
+		const response = await getQueueSkillService().readQueueSkill(
+			Number(parentId),
+			Number(id),
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addQueueSkill = async ({
+	parentId,
+	itemInstance,
+}: NestedAddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getQueueSkillService().createQueueSkill(
+			Number(parentId),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateQueueSkill = async ({
+	itemInstance,
+	itemId: id,
+	parentId,
+}: NestedUpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getQueueSkillService().updateQueueSkill(
+			Number(parentId),
+			Number(id),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchQueueSkill = async ({
+	changes,
+	id,
+	parentId,
+}: NestedPatchItemParams) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getQueueSkillService().patchQueueSkill(
+			Number(parentId),
+			Number(id),
+			body,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteQueueSkill = async ({ parentId, id }: NestedDeleteItemParams) => {
+	try {
+		const response = await getQueueSkillService().deleteQueueSkill(
+			Number(parentId),
+			Number(id),
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const QueueSkillsAPI = {
+	getList: getQueueSkillsList,
+	get: getQueueSkill,
+	add: addQueueSkill,
+	patch: patchQueueSkill,
+	update: updateQueueSkill,
+	delete: deleteQueueSkill,
+};

package/src/api/clients/queues/queueState.ts

@@ -0,0 +1,97 @@
+import {
+	GetQueuesGlobalStateQueryParams,
+	getQueueService,
+	SetQueuesGlobalStateBody,
+} from '@webitel/api-services/gen';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import {
+	applyTransform,
+	camelToSnake,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type { ApiParams } from '../_shared/types';
+
+/**
+ * The queues registry's global enable/disable switcher. It reports and flips
+ * the state of every queue matching the table's current filters, so it takes
+ * the same filter names the datalist store holds and maps them onto the
+ * service's own param names.
+ */
+const mapFilters = (params: ApiParams) => ({
+	q: params.search,
+	type: params.queueType,
+	teamId: params.team,
+	tags: params.tags,
+});
+
+const getQueuesGlobalState = async (params: ApiParams = {}) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+		GetQueuesGlobalStateQueryParams,
+	);
+
+	const transformedParams = applyTransform(params, [
+		starToSearch('search'),
+		mapFilters,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response =
+			await getQueueService().getQueuesGlobalState(transformedParams);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const setQueuesGlobalState = async ({
+	enabled,
+	params,
+}: {
+	enabled: boolean;
+	params: ApiParams;
+}) => {
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+		SetQueuesGlobalStateBody,
+	);
+
+	const transformedParams = applyTransform(params, [
+		starToSearch('search'),
+		mapFilters,
+	]);
+
+	const body = applyTransform(
+		{
+			enabled: !!enabled,
+			...transformedParams,
+		},
+		[
+			sanitize(fieldsToSend),
+			camelToSnake(),
+		],
+	);
+
+	try {
+		const response = await getQueueService().setQueuesGlobalState(body);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const QueuesStateAPI = {
+	getQueuesGlobalState,
+	setQueuesGlobalState,
+};

package/src/api/clients/queues/queues.ts

@@ -1,12 +1,11 @@
+import { getQueueService } from '@webitel/api-services/gen';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { queueSchema } from '@webitel/api-services/validations';
 import deepCopy from 'deep-copy';
+import deepmerge from 'deepmerge';
 import { isEmpty } from 'lodash-es';
-import { QueueServiceApiFactory } from 'webitel-sdk';
-import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+import { QueueType } from '../../../enums';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
@@ -17,6 +16,7 @@ import {
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
+import { generatePermissionsApi } from '../_shared/generatePermissionsApi';
 import type {
 	AddItemParams,
 	ApiParams,
@@ -25,45 +25,53 @@ import type {
 	PatchItemParams,
 	UpdateItemParams,
 } from '../_shared/types';
-import processing from './defaults/processing';
-
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
+import { processing } from './defaults/processing';
+import { getQueueDefaults } from './defaults/queueTypeDefaults';
 
-const queueService = QueueServiceApiFactory(configuration, '', instance);
+const baseUrl = '/call_center/queues';
 
 const doNotConvertKeys = [
 	'variables',
 ];
 
-const fieldsToSend = [
-	'name',
-	'type',
-	'strategy',
-	'team',
-	'priority',
-	'dncList',
-	'schema',
-	'payload',
-	'taskProcessing',
-	'maxOfRetry',
-	'timeout',
-	'secBetweenRetries',
-	'variables',
-	'calendar',
-	'description',
-	'enabled',
-	'ringtone',
-	'doSchema',
-	'afterSchema',
-	'stickyAgent',
-	'grantee',
-	'tags',
-];
+/**
+ * Derived from the schema, so the form and the request cannot drift apart.
+ *
+ * Note this sends top-level `formSchema`, which the previous hand-written list
+ * omitted even though chat queues seed it and the service accepts it.
+ */
+const fieldsToSend = getShallowFieldsToSendFromZodSchema(queueSchema);
+
+/**
+ * proto3 omits zero values on the wire, and `OFFLINE_QUEUE` is `0` — so an
+ * offline queue comes back with no `type` key at all.
+ *
+ * This is not cosmetic: everything downstream keys on `type`. Without it
+ * `getQueueDefaults` falls through to the type-agnostic base, the Params tab
+ * renders no type-specific controls, and `queueSchema`'s `superRefine` skips
+ * the per-type branch entirely — all silently. Restore it before any reader
+ * sees the item.
+ */
+const restoreOmittedType = (item: ApiParams) => ({
+	type: QueueType.OFFLINE_QUEUE,
+	...item,
+});
+
+/**
+ * Same proto3 omission, for the columns the table renders directly. Legacy did
+ * this via a `defaultObject`; these are the zero values, not form defaults.
+ */
+const listZeroValues = {
+	enabled: false,
+	active: 0,
+	waiting: 0,
+	priority: 0,
+};
 
 const preRequestHandler = (item: ApiParams) => {
 	const copy = deepCopy(item);
-	copy.variables = copy.variables.reduce(
+	// a queue whose `variables` the service omitted arrives without the key
+	copy.variables = (copy.variables ?? []).reduce(
 		(variables: ApiParams, variable: ApiParams) => {
 			if (!variable.key) return variables;
 			variables[variable.key] = variable.value;
@@ -75,14 +83,6 @@ const preRequestHandler = (item: ApiParams) => {
 };
 
 const getQueuesList = async (params: ApiParams) => {
-	const defaultObject = {
-		type: 0,
-		enabled: false,
-		active: 0,
-		waiting: 0,
-		priority: '0',
-	};
-
 	const { page, size, search, sort, fields, id, queueType, team, tags } =
 		applyTransform(params, [
 			merge(getDefaultGetParams()),
@@ -90,24 +90,29 @@ const getQueuesList = async (params: ApiParams) => {
 		]);
 
 	try {
-		const response = await queueService.searchQueue(
+		const response = await getQueueService().searchQueue({
 			page,
 			size,
-			search,
+			// the generated param is `q`; `search` is what the datalist store sends
+			q: search,
 			sort,
 			fields,
 			id,
-			queueType,
-			team,
+			// the service names these after the fields, not after the filters
+			type: queueType,
+			teamId: team,
 			tags,
-		);
+		});
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(doNotConvertKeys),
 			merge(getDefaultGetListResponse()),
 		]);
 		return {
 			items: applyTransform(items, [
-				mergeEach(defaultObject),
+				mergeEach({
+					...listZeroValues,
+					type: QueueType.OFFLINE_QUEUE,
+				}),
 			]),
 			next,
 		};
@@ -118,38 +123,57 @@ const getQueuesList = async (params: ApiParams) => {
 	}
 };
 
+const responseHandler = (item: ApiParams) => {
+	const copy = deepCopy(item);
+	if (copy.variables) {
+		copy.variables = Object.keys(copy.variables).map((key) => ({
+			key,
+			value: copy.variables[key],
+		}));
+	}
+	if (isEmpty(copy.taskProcessing)) {
+		copy.taskProcessing = processing({
+			enabled: !!copy.processing,
+			formSchema: copy.formSchema,
+			sec: copy.processingSec || 0,
+			renewalSec: copy.processingRenewalSec || 0,
+		});
+	}
+	return copy;
+};
+
+/**
+ * Seeds every field the queue's type can use, so the card form has a
+ * complete draft. Regle derives its nested `$fields` from state keys, not
+ * from the Zod schema, so a key the backend omitted would otherwise have no
+ * validation entry — no required marker, no error text, silently.
+ *
+ * Runs AFTER `responseHandler` on purpose: the handler back-fills
+ * `taskProcessing` from the legacy flat fields only while it `isEmpty`, and
+ * seeding the defaults first would suppress that. The item stays last in
+ * the merge, so real values always win over defaults.
+ */
+const mergeTypeDefaults = (item: ApiParams) =>
+	deepmerge(getQueueDefaults(item.type), item);
+
+/**
+ * `add` and `update` answer with the saved queue, and the card store adopts
+ * that response as its new state instead of re-reading the queue — so it has
+ * to arrive in exactly the shape `get` returns. Without this the form loses
+ * the `variables` pair list (the next save then throws), the reconstructed
+ * `taskProcessing`, and an offline queue's `type`.
+ */
+const cardResponseTransforms = [
+	snakeToCamel(doNotConvertKeys),
+	restoreOmittedType,
+	responseHandler,
+	mergeTypeDefaults,
+];
+
 const getQueue = async ({ itemId: id }: GetItemParams) => {
-	const defaultObject = {
-		tags: [],
-		type: 0,
-		formSchema: {},
-		taskProcessing: {},
-	};
-	const responseHandler = (item: ApiParams) => {
-		const copy = deepCopy(item);
-		if (copy.variables) {
-			copy.variables = Object.keys(copy.variables).map((key) => ({
-				key,
-				value: copy.variables[key],
-			}));
-		}
-		if (isEmpty(copy.taskProcessing)) {
-			copy.taskProcessing = processing({
-				enabled: !!copy.processing,
-				formSchema: copy.formSchema,
-				sec: copy.processingSec || 0,
-				renewalSec: copy.processingRenewalSec || 0,
-			});
-		}
-		return copy;
-	};
 	try {
-		const response = await queueService.readQueue(String(id));
-		return applyTransform(response.data, [
-			snakeToCamel(doNotConvertKeys),
-			merge(defaultObject),
-			responseHandler,
-		]);
+		const response = await getQueueService().readQueue(String(id));
+		return applyTransform(response.data, cardResponseTransforms);
 	} catch (err) {
 		throw applyTransform(err, [
 			notify,
@@ -164,10 +188,8 @@ const addQueue = async ({ itemInstance }: AddItemParams) => {
 		camelToSnake(doNotConvertKeys),
 	]);
 	try {
-		const response = await queueService.createQueue(item);
-		return applyTransform(response.data, [
-			snakeToCamel(doNotConvertKeys),
-		]);
+		const response = await getQueueService().createQueue(item);
+		return applyTransform(response.data, cardResponseTransforms);
 	} catch (err) {
 		throw applyTransform(err, [
 			notify,
@@ -182,10 +204,8 @@ const updateQueue = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 		camelToSnake(doNotConvertKeys),
 	]);
 	try {
-		const response = await queueService.updateQueue(String(id), item);
-		return applyTransform(response.data, [
-			snakeToCamel(doNotConvertKeys),
-		]);
+		const response = await getQueueService().updateQueue(String(id), item);
+		return applyTransform(response.data, cardResponseTransforms);
 	} catch (err) {
 		throw applyTransform(err, [
 			notify,
@@ -199,7 +219,7 @@ const patchQueue = async ({ id, changes }: PatchItemParams) => {
 		camelToSnake(doNotConvertKeys),
 	]);
 	try {
-		const response = await queueService.patchQueue(String(id), item);
+		const response = await getQueueService().patchQueue(String(id), item);
 		return applyTransform(response.data, [
 			snakeToCamel(doNotConvertKeys),
 		]);
@@ -212,7 +232,7 @@ const patchQueue = async ({ id, changes }: PatchItemParams) => {
 
 const deleteQueue = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await queueService.deleteQueue(String(id));
+		const response = await getQueueService().deleteQueue(String(id));
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -238,13 +258,13 @@ const getQueuesTags = async (params: ApiParams) => {
 		camelToSnake(doNotConvertKeys),
 	]);
 	try {
-		const response = await queueService.searchQueueTags(
+		const response = await getQueueService().searchQueueTags({
 			page,
 			size,
-			search,
+			q: search,
 			sort,
 			fields,
-		);
+		});
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(doNotConvertKeys),
 			merge(getDefaultGetListResponse()),
@@ -260,6 +280,13 @@ const getQueuesTags = async (params: ApiParams) => {
 	}
 };
 
+export type { QueueDefaults } from './defaults/queueTypeDefaults';
+export {
+	getQueueDefaults,
+	hasQueueTypeDefaults,
+	QueueTypeDefaults,
+} from './defaults/queueTypeDefaults';
+
 export const QueuesAPI = {
 	getList: getQueuesList,
 	get: getQueue,
@@ -269,4 +296,7 @@ export const QueuesAPI = {
 	delete: deleteQueue,
 	getLookup: getQueuesLookup,
 	getQueuesTags,
+	// `getPermissionsList` + `patchPermissions`, the pair PermissionsApiModule
+	// adapts for ui-datalist's permissions page.
+	...generatePermissionsApi(baseUrl),
 };