@webitel/api-services 0.1.69 → 0.1.70

package/src/api/clients/queues/defaults/__tests__/queueTypeDefaults.spec.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from 'vitest';
+
+import { QueueType } from '../../../../../enums';
+import { processing } from '../processing';
+import {
+	getQueueDefaults,
+	hasQueueTypeDefaults,
+	QueueTypeDefaults,
+} from '../queueTypeDefaults';
+
+const allQueueTypes = Object.values(QueueType);
+
+/** The two types whose legacy schema deliberately has no `taskProcessing`. */
+const typesWithoutTaskProcessing = [
+	QueueType.OUTBOUND_IVR_QUEUE,
+	QueueType.OUTBOUND_JOB_QUEUE,
+];
+
+/** The three types whose legacy schema carries `payload.amd`. */
+const typesWithAmd = [
+	QueueType.OUTBOUND_IVR_QUEUE,
+	QueueType.PROGRESSIVE_DIALER,
+	QueueType.PREDICTIVE_DIALER,
+];
+
+describe('queue type defaults', () => {
+	it('has a factory for every QueueType', () => {
+		for (const type of allQueueTypes) {
+			expect(QueueTypeDefaults[type], `missing factory for ${type}`).toBeTypeOf(
+				'function',
+			);
+		}
+		expect(Object.keys(QueueTypeDefaults)).toHaveLength(allQueueTypes.length);
+	});
+
+	it('stamps each factory with its own type', () => {
+		for (const type of allQueueTypes) {
+			expect(QueueTypeDefaults[type]().type).toBe(type);
+		}
+	});
+
+	/**
+	 * The legacy code used factories precisely so two queues never shared a
+	 * nested object. A plain object export would let edits on one new queue
+	 * leak into the next one opened.
+	 */
+	it('returns a fresh deep object on every call', () => {
+		for (const type of allQueueTypes) {
+			const a = QueueTypeDefaults[type]();
+			const b = QueueTypeDefaults[type]();
+
+			expect(a).not.toBe(b);
+			expect(a).toEqual(b);
+			expect(a.payload).not.toBe(b.payload);
+			expect(a.variables).not.toBe(b.variables);
+		}
+	});
+
+	it('keeps taskProcessing exactly where the legacy schema had it', () => {
+		for (const type of allQueueTypes) {
+			const defaults = QueueTypeDefaults[type]();
+
+			if (typesWithoutTaskProcessing.includes(type)) {
+				expect(defaults.taskProcessing, `${type}`).toBeUndefined();
+			} else {
+				expect(defaults.taskProcessing, `${type}`).toBeDefined();
+			}
+		}
+	});
+
+	it('keeps payload.amd exactly where the legacy schema had it', () => {
+		for (const type of allQueueTypes) {
+			const { payload } = QueueTypeDefaults[type]();
+
+			expect(Boolean(payload.amd), `${type}`).toBe(typesWithAmd.includes(type));
+		}
+	});
+
+	/**
+	 * Regression guard: api-services' `processing()` used to omit
+	 * `prolongationOptions`, which left the Processing tab's prolongation block
+	 * without Regle `$fields` — no required markers, no error text.
+	 */
+	it('seeds taskProcessing.prolongationOptions', () => {
+		expect(processing().prolongationOptions).toEqual({
+			enabled: false,
+			isTimeoutRetry: false,
+			prolongationTimeSec: 30,
+			repeatsNumber: 1,
+		});
+
+		const defaults = QueueTypeDefaults[QueueType.INBOUND_QUEUE]();
+
+		expect(defaults.taskProcessing).toMatchObject({
+			prolongationOptions: {
+				repeatsNumber: 1,
+			},
+		});
+	});
+
+	it('treats IM_CHAT_QUEUE as CHAT_INBOUND_QUEUE apart from the type', () => {
+		const chat = QueueTypeDefaults[QueueType.CHAT_INBOUND_QUEUE]();
+		const imChat = QueueTypeDefaults[QueueType.IM_CHAT_QUEUE]();
+
+		expect({
+			...imChat,
+			type: chat.type,
+		}).toEqual(chat);
+	});
+});
+
+describe('getQueueDefaults', () => {
+	it('resolves a numeric type', () => {
+		expect(getQueueDefaults(QueueType.PREVIEW_DIALER).type).toBe(
+			QueueType.PREVIEW_DIALER,
+		);
+	});
+
+	/** The card page reads `?type=` off the route, so it arrives as a string. */
+	it('resolves a stringified type from the route query', () => {
+		expect(getQueueDefaults(String(QueueType.PREDICTIVE_DIALER)).type).toBe(
+			QueueType.PREDICTIVE_DIALER,
+		);
+	});
+
+	it('falls back to the base queue shape for an unknown type', () => {
+		const defaults = getQueueDefaults(undefined);
+
+		expect(defaults.type).toBeUndefined();
+		expect(defaults).toMatchObject({
+			name: '',
+			priority: 0,
+			variables: [],
+		});
+	});
+
+	it('reports whether a type has defaults', () => {
+		expect(hasQueueTypeDefaults(QueueType.OFFLINE_QUEUE)).toBe(true);
+		expect(hasQueueTypeDefaults('4')).toBe(true);
+		expect(hasQueueTypeDefaults(42)).toBe(false);
+		expect(hasQueueTypeDefaults(undefined)).toBe(false);
+	});
+});

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

@@ -0,0 +1,17 @@
+export const amd = () => ({
+	enabled: false,
+	ai: false,
+	positive: [],
+	playback: {},
+	allowNotSure: false,
+	silenceNotSure: false,
+	maxWordLength: 5000,
+	maxNumberOfWords: 3,
+	betweenWordsSilence: 50,
+	minWordLength: 100,
+	totalAnalysisTime: 5000,
+	silenceThreshold: 256,
+	afterGreetingSilence: 800,
+	greeting: 1500,
+	initialSilence: 2500,
+});

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

@@ -0,0 +1,9 @@
+export const defaultQueue = () => ({
+	name: '',
+	description: '',
+	priority: 0,
+	tags: [],
+	dncList: {},
+	calendar: {},
+	variables: [],
+});

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

@@ -1,14 +1,18 @@
 import deepmerge from 'deepmerge';
 
-const processing = (processing = {}) =>
+export const processing = (overrides = {}) =>
 	deepmerge(
 		{
 			enabled: false,
 			formSchema: {},
 			sec: 30,
 			renewalSec: 15,
+			prolongationOptions: {
+				enabled: false,
+				isTimeoutRetry: false,
+				prolongationTimeSec: 30,
+				repeatsNumber: 1,
+			},
 		},
-		processing,
+		overrides,
 	);
-
-export default processing;

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

@@ -0,0 +1,305 @@
+import {
+	QueueStrategy,
+	QueueType,
+	TimeBaseScore,
+	TypesResourceStrategy,
+} from '../../../../enums';
+import { amd } from './amd';
+import { defaultQueue } from './defaultQueue';
+import { processing } from './processing';
+
+/**
+ * @description
+ * The default field set a queue of a given type is created with.
+ *
+ * These are NOT cosmetic. Regle builds its nested `$fields` from the *state*
+ * keys, not from the Zod schema shape — a field that is declared in
+ * `queueSchema` but missing from the draft has no validation entry at all, so
+ * its required marker and error text silently disappear from the form.
+ * Every key a queue type's UI can touch must therefore be seeded here, on
+ * create (via the card store) and on read (see `QueuesAPI.get`).
+ *
+ * Ported 1:1 from the admin app's legacy `store/_internals/queueSchema/*.js`.
+ * Keep the per-type key sets exactly as they are: `sanitize(fieldsToSend)` only
+ * filters top-level keys, so `payload` is sent whole and a stray cross-type
+ * field (e.g. `progressiveCount` on an inbound queue) would reach the backend.
+ */
+export interface QueueDefaults {
+	[key: string]: unknown;
+	type: QueueType;
+	payload: Record<string, unknown>;
+}
+
+const offlineQueue = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.OFFLINE_QUEUE,
+	team: {},
+	strategy: QueueStrategy.FIFO,
+	doSchema: {},
+	afterSchema: {},
+	grantee: {},
+	taskProcessing: processing(),
+	payload: {
+		maxAttempts: 3,
+		waitBetweenRetries: 30 * 60,
+		originateTimeout: 60,
+		recordings: false,
+		recordAll: false,
+		perNumbers: false,
+		minOnlineAgents: 0,
+		maxMemberLimit: 0,
+	},
+});
+
+const inboundQueue = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.INBOUND_QUEUE,
+	team: {},
+	ringtone: {},
+	grantee: {},
+	stickyAgent: false,
+	taskProcessing: processing(),
+	payload: {
+		discardAbandonedAfter: 0,
+		timeBaseScore: TimeBaseScore.QUEUE,
+		maxWaitTime: 60 * 60,
+		allowGreetingAgent: false,
+		stickyIgnoreStatus: false,
+		ignoreCalendar: false,
+		stickyAgentSec: 5,
+		maxWaitingSize: 0,
+		autoAnswerTone: null,
+		minOnlineAgents: 0,
+		manualDistribution: false,
+		maxMemberLimit: 0,
+	},
+});
+
+/** NB: no `taskProcessing` — matches the legacy schema exactly. */
+const outboundIVRQueue = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.OUTBOUND_IVR_QUEUE,
+	strategy: QueueStrategy.FIFO,
+	schema: {},
+	doSchema: {},
+	afterSchema: {},
+	grantee: {},
+	payload: {
+		minDuration: 3,
+		maxAttempts: 3,
+		originateTimeout: 60,
+		waitBetweenRetries: 30 * 60,
+		waitBetweenRetriesDesc: false,
+		maxCalls: 10,
+		recordings: false,
+		recordAll: false,
+		amd: amd(),
+		strictCircuit: false,
+		perNumbers: false,
+		resourceStrategy: TypesResourceStrategy.EVEN_DISTRIBUTION,
+		maxMemberLimit: 0,
+	},
+});
+
+const previewDialer = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.PREVIEW_DIALER,
+	team: {},
+	strategy: QueueStrategy.FIFO,
+	doSchema: {},
+	afterSchema: {},
+	grantee: {},
+	stickyAgent: false,
+	taskProcessing: processing(),
+	payload: {
+		maxAttempts: 3,
+		originateTimeout: 60,
+		waitBetweenRetries: 30 * 60,
+		waitBetweenRetriesDesc: false,
+		maxCalls: 10,
+		recordings: false,
+		recordAll: false,
+		allowGreetingAgent: false,
+		strictCircuit: false,
+		endless: false,
+		perNumbers: false,
+		minOnlineAgents: 0,
+		resourceStrategy: TypesResourceStrategy.EVEN_DISTRIBUTION,
+		maxMemberLimit: 0,
+	},
+});
+
+const progressiveDialer = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.PROGRESSIVE_DIALER,
+	team: {},
+	strategy: QueueStrategy.FIFO,
+	doSchema: {},
+	afterSchema: {},
+	ringtone: {},
+	grantee: {},
+	stickyAgent: false,
+	taskProcessing: processing(),
+	payload: {
+		maxAttempts: 3,
+		originateTimeout: 60,
+		waitBetweenRetries: 30 * 60,
+		progressiveCount: 1,
+		waitBetweenRetriesDesc: false,
+		recordings: false,
+		recordAll: false,
+		allowGreetingAgent: false,
+		maxCalls: 10,
+		amd: amd(),
+		strictCircuit: false,
+		endless: false,
+		perNumbers: false,
+		autoAnswerTone: null,
+		minOnlineAgents: 0,
+		resourceStrategy: TypesResourceStrategy.EVEN_DISTRIBUTION,
+		maxMemberLimit: 0,
+	},
+});
+
+const predictiveDialer = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.PREDICTIVE_DIALER,
+	strategy: QueueStrategy.FIFO,
+	team: {},
+	doSchema: {},
+	afterSchema: {},
+	ringtone: {},
+	grantee: {},
+	stickyAgent: false,
+	taskProcessing: processing(),
+	payload: {
+		maxWaitTime: 10,
+		maxAttempts: 3,
+		originateTimeout: 60,
+		waitBetweenRetries: 30 * 60,
+		progressiveCount: 1,
+		waitBetweenRetriesDesc: false,
+		retryAbandoned: false,
+		recordings: false,
+		recordAll: false,
+		allowGreetingAgent: false,
+		maxCalls: 10,
+		dialingRate: 5,
+		amd: amd(),
+		maxAgentLine: 5,
+		minAttempts: 3,
+		maxAbandonedRate: 5.0,
+		targetAbandonedRate: 3.0,
+		loadFactor: 10,
+		maxAgentLose: 1,
+		abandonRateAdjustment: 0,
+		playbackSilence: 0,
+		strictCircuit: false,
+		statisticTime: 60,
+		endless: false,
+		perNumbers: false,
+		stickyAgentSec: 5,
+		autoAnswerTone: null,
+		minOnlineAgents: 0,
+		resourceStrategy: TypesResourceStrategy.EVEN_DISTRIBUTION,
+		maxMemberLimit: 0,
+	},
+});
+
+const chatInboundQueue = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.CHAT_INBOUND_QUEUE,
+	team: {},
+	strategy: QueueStrategy.FIFO,
+	formSchema: {},
+	stickyAgent: false,
+	taskProcessing: processing(),
+	payload: {
+		discardAbandonedAfter: 0,
+		timeBaseScore: TimeBaseScore.QUEUE,
+		maxWaitTime: 60 * 60,
+		stickyAgentSec: 5,
+		stickyIgnoreStatus: false,
+		ignoreCalendar: false,
+		maxIdleAgent: 60 * 60,
+		maxIdleClient: 60 * 60,
+		maxIdleDialog: 0,
+		maxWaitingSize: 0,
+		minOnlineAgents: 0,
+		manualDistribution: false,
+		lastMessageTimeout: false,
+		maxMemberLimit: 0,
+	},
+});
+
+/** Identical to CHAT_INBOUND_QUEUE apart from `type` — as in the legacy schema. */
+const imChatQueue = (): QueueDefaults => ({
+	...chatInboundQueue(),
+	type: QueueType.IM_CHAT_QUEUE,
+});
+
+const inboundJobQueue = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.INBOUND_JOB_QUEUE,
+	team: {},
+	strategy: QueueStrategy.FIFO,
+	doSchema: {},
+	afterSchema: {},
+	stickyAgent: false,
+	taskProcessing: processing(),
+	payload: {
+		maxAttempts: 3,
+		waitBetweenRetries: 30 * 60,
+		maxCalls: 10,
+		waitBetweenRetriesDesc: false,
+		minOnlineAgents: 0,
+		maxMemberLimit: 0,
+	},
+});
+
+/** NB: no `taskProcessing` — matches the legacy schema exactly. */
+const outboundJobQueue = (): QueueDefaults => ({
+	...defaultQueue(),
+	type: QueueType.OUTBOUND_JOB_QUEUE,
+	strategy: QueueStrategy.FIFO,
+	schema: {},
+	doSchema: {},
+	afterSchema: {},
+	payload: {
+		maxAttempts: 3,
+		originateTimeout: 60,
+		waitBetweenRetries: 30 * 60,
+		waitBetweenRetriesDesc: false,
+		maxCalls: 10,
+		strictCircuit: false,
+		perNumbers: false,
+		maxMemberLimit: 0,
+	},
+});
+
+export const QueueTypeDefaults: Record<number, () => QueueDefaults> = {
+	[QueueType.OFFLINE_QUEUE]: offlineQueue,
+	[QueueType.INBOUND_QUEUE]: inboundQueue,
+	[QueueType.OUTBOUND_IVR_QUEUE]: outboundIVRQueue,
+	[QueueType.PREVIEW_DIALER]: previewDialer,
+	[QueueType.PROGRESSIVE_DIALER]: progressiveDialer,
+	[QueueType.PREDICTIVE_DIALER]: predictiveDialer,
+	[QueueType.CHAT_INBOUND_QUEUE]: chatInboundQueue,
+	[QueueType.IM_CHAT_QUEUE]: imChatQueue,
+	[QueueType.INBOUND_JOB_QUEUE]: inboundJobQueue,
+	[QueueType.OUTBOUND_JOB_QUEUE]: outboundJobQueue,
+};
+
+export const hasQueueTypeDefaults = (type: number | string | undefined) =>
+	Number(type) in QueueTypeDefaults;
+
+/**
+ * @description
+ * A fresh defaults object for `type`. Always a new object — callers deepmerge
+ * into it, and the legacy code relied on factories for exactly this reason.
+ * Falls back to the type-agnostic base when `type` is unknown.
+ */
+export const getQueueDefaults = (
+	type: number | string | undefined,
+): Partial<QueueDefaults> =>
+	QueueTypeDefaults[Number(type)]?.() ?? defaultQueue();

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

@@ -0,0 +1,48 @@
+import { getAgentService } from '@webitel/api-services/gen';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	merge,
+	notify,
+	snakeToCamel,
+} from '../../transformers';
+import type { ApiParams } from '../_shared/types';
+
+const getQueueAgentsList = async (params: ApiParams) => {
+	const { parentId, page, size, search, fields, sort } = applyTransform(
+		params,
+		[
+			merge(getDefaultGetParams()),
+		],
+	);
+
+	try {
+		const response = await getAgentService().searchAgent({
+			page,
+			size,
+			// the generated param is `q`; `search` is what the datalist store sends
+			q: search,
+			sort,
+			fields,
+			queueId: [
+				Number(parentId),
+			],
+		});
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const QueueAgentsAPI = {
+	getList: getQueueAgentsList,
+};