@webitel/api-services 0.1.69 → 0.1.70

package/src/api/clients/queues/scripts/__tests__/mapResetMembersFilters.spec.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+	mapResetMembersFilters,
+	mapResetMembersQuantityFilters,
+} from '../mapResetMembersFilters';
+
+describe('mapResetMembersFilters', () => {
+	it('maps the datalist filter names onto the reset body', () => {
+		expect(
+			mapResetMembersFilters({
+				agent: [
+					1,
+				],
+				bucket: [
+					2,
+				],
+				createdAt: {
+					from: 100,
+					to: 200,
+				},
+				memberPriority: {
+					from: 1,
+					to: 9,
+				},
+				search: 'joe',
+				stopCause: [
+					'cancel',
+				],
+			}),
+		).toEqual({
+			agent_id: [
+				1,
+			],
+			bucket_id: [
+				2,
+			],
+			created_at: {
+				from: 100,
+				to: 200,
+			},
+			priority: {
+				from: 1,
+				to: 9,
+			},
+			q: 'joe',
+			stop_cause: [
+				'cancel',
+			],
+		});
+	});
+
+	/**
+	 * The members table shipped flat `from`/`to`/`cause`/`priority` names before
+	 * the migration; both spellings are accepted so the two can coexist.
+	 */
+	it('still accepts the legacy flat filter names', () => {
+		const mapped = mapResetMembersFilters({
+			from: 100,
+			to: 200,
+			cause: [
+				'cancel',
+			],
+			priority: {
+				from: 1,
+				to: 9,
+			},
+		});
+
+		expect(mapped.created_at).toEqual({
+			from: 100,
+			to: 200,
+		});
+		expect(mapped.priority).toEqual({
+			from: 1,
+			to: 9,
+		});
+		expect(mapped.stop_cause).toEqual([
+			'cancel',
+		]);
+	});
+
+	it('leaves every bound undefined when nothing is filtered', () => {
+		expect(mapResetMembersFilters()).toEqual({
+			agent_id: undefined,
+			bucket_id: undefined,
+			created_at: {
+				from: undefined,
+				to: undefined,
+			},
+			priority: {
+				from: undefined,
+				to: undefined,
+			},
+			q: undefined,
+			stop_cause: undefined,
+		});
+	});
+});
+
+describe('mapResetMembersQuantityFilters', () => {
+	/**
+	 * The count endpoint is a GET, so the nested range messages have to be
+	 * spelled out as dotted query keys rather than nested objects.
+	 */
+	it('flattens the ranges into dotted query keys', () => {
+		const mapped = mapResetMembersQuantityFilters({
+			createdAt: {
+				from: 100,
+				to: 200,
+			},
+			memberPriority: {
+				from: 1,
+				to: 9,
+			},
+			search: 'joe',
+		});
+
+		expect(mapped).toEqual({
+			agent_id: undefined,
+			bucket_id: undefined,
+			'created_at.from': 100,
+			'created_at.to': 200,
+			'priority.from': 1,
+			'priority.to': 9,
+			q: 'joe',
+			stop_cause: undefined,
+		});
+		expect(mapped).not.toHaveProperty('created_at');
+		expect(mapped).not.toHaveProperty('priority');
+	});
+});

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

@@ -0,0 +1,52 @@
+import type { ApiParams } from '../../_shared/types';
+
+/**
+ * The members table, the "reset members" action and the "how many will this
+ * affect?" counter all read the same filter set, but the three endpoints want
+ * it in three different shapes.
+ *
+ * Filter names accept both the datalist names (`createdAt`, `stopCause`,
+ * `memberPriority`) and the legacy flat ones (`from`/`to`, `cause`,
+ * `priority`). `createdAt` and `memberPriority` arrive already resolved to
+ * `{ from, to }` — relative values like "today" are resolved app-side, where
+ * the user's timezone lives.
+ */
+const range = (value: ApiParams | undefined, from?: number, to?: number) => ({
+	from: value?.from ?? from,
+	to: value?.to ?? to,
+});
+
+export const mapResetMembersFilters = (filters: ApiParams = {}) => {
+	const createdAt = range(filters.createdAt, filters.from, filters.to);
+	const priority = range(
+		filters.memberPriority ?? filters.priority,
+		filters.priorityFrom,
+		filters.priorityTo,
+	);
+
+	return {
+		agent_id: filters.agent,
+		bucket_id: filters.bucket,
+		created_at: createdAt,
+		priority,
+		q: filters.search,
+		stop_cause: filters.stopCause ?? filters.cause,
+	};
+};
+
+/**
+ * The count endpoint is a GET, so the nested messages have to be spelled out
+ * as dotted query keys. `qs` emits these unencoded, which is what the backend
+ * expects — do NOT let `camelToSnake` near them.
+ */
+export const mapResetMembersQuantityFilters = (filters: ApiParams = {}) => {
+	const { created_at, priority, ...rest } = mapResetMembersFilters(filters);
+
+	return {
+		...rest,
+		'created_at.from': created_at.from,
+		'created_at.to': created_at.to,
+		'priority.from': priority.from,
+		'priority.to': priority.to,
+	};
+};

package/src/enums/CallReportingStatus/CallReportingStatus.ts

@@ -0,0 +1,13 @@
+export const CallReportingStatus = {
+	ABANDONED: 'abandoned',
+	CANCEL: 'cancel',
+	SUCCESS: 'success',
+	FAILED: 'failed',
+	MISSED: 'missed',
+	TIMEOUT: 'timeout',
+	ENDLESS: 'endless',
+	TRANSFERRED: 'transferred',
+} as const;
+
+export type CallReportingStatus =
+	(typeof CallReportingStatus)[keyof typeof CallReportingStatus];

package/src/enums/MemberStopCause/MemberStopCause.ts

@@ -0,0 +1,13 @@
+export const MemberStopCause = {
+	MISSED: 'missed',
+	TIMEOUT: 'timeout',
+	FAILED: 'failed',
+	ABANDONED: 'abandoned',
+	SUCCESS: 'success',
+	CANCEL: 'cancel',
+	EXPIRED: 'expired',
+	CANCELED_BY_TIMEOUT: 'canceled_by_timeout',
+} as const;
+
+export type MemberStopCause =
+	(typeof MemberStopCause)[keyof typeof MemberStopCause];

package/src/enums/QueueStrategy/QueueStrategy.ts

@@ -0,0 +1,27 @@
+export const QueueStrategy = {
+	FIFO: 'fifo',
+	LIFO: 'lifo',
+	STRICT_FIFO: 'strict_fifo',
+} as const;
+
+export type QueueStrategy = (typeof QueueStrategy)[keyof typeof QueueStrategy];
+
+/**
+ * @description
+ * Select options for the queue `strategy` field, in display order.
+ * `name` is the raw label the admin UI shows — not a locale key.
+ */
+export const QueueStrategyList = [
+	{
+		name: 'FIFO',
+		value: QueueStrategy.FIFO,
+	},
+	{
+		name: 'LIFO',
+		value: QueueStrategy.LIFO,
+	},
+	{
+		name: 'STRICT_FIFO',
+		value: QueueStrategy.STRICT_FIFO,
+	},
+] as const;

package/src/enums/QueueType/QueueType.ts

@@ -0,0 +1,31 @@
+export const QueueType = {
+	OFFLINE_QUEUE: 0,
+	INBOUND_QUEUE: 1,
+	OUTBOUND_IVR_QUEUE: 2,
+	PREVIEW_DIALER: 3,
+	PROGRESSIVE_DIALER: 4,
+	PREDICTIVE_DIALER: 5,
+	CHAT_INBOUND_QUEUE: 6,
+	INBOUND_JOB_QUEUE: 7,
+	OUTBOUND_JOB_QUEUE: 8,
+	IM_CHAT_QUEUE: 9,
+} as const;
+
+export type QueueType = (typeof QueueType)[keyof typeof QueueType];
+
+export const QueueTypeName = {
+	OFFLINE_QUEUE: 'offline',
+	INBOUND_QUEUE: 'inbound',
+	OUTBOUND_IVR_QUEUE: 'ivr',
+	PREVIEW_DIALER: 'preview',
+	PROGRESSIVE_DIALER: 'progressive',
+	PREDICTIVE_DIALER: 'predictive',
+	CHAT_INBOUND_QUEUE: 'inbound chat',
+	INBOUND_JOB_QUEUE: 'task',
+	OUTBOUND_JOB_QUEUE: 'outbound_task',
+	OUTBOUND_CALL: 'outbound_call',
+	IM_CHAT_QUEUE: 'im_chat',
+	NOT_IMPLEMENT: 'NOT_IMPLEMENT',
+} as const;
+
+export type QueueTypeName = (typeof QueueTypeName)[keyof typeof QueueTypeName];

package/src/enums/TimeBaseScore/TimeBaseScore.ts

@@ -0,0 +1,6 @@
+export const TimeBaseScore = {
+	QUEUE: 'queue',
+	SYSTEM: 'system',
+} as const;
+
+export type TimeBaseScore = (typeof TimeBaseScore)[keyof typeof TimeBaseScore];

package/src/enums/TypesResourceStrategy/TypesResourceStrategy.ts

@@ -0,0 +1,7 @@
+export const TypesResourceStrategy = {
+	PRIORITY_BASED: 'priority-based',
+	EVEN_DISTRIBUTION: 'even-distribution',
+} as const;
+
+export type TypesResourceStrategy =
+	(typeof TypesResourceStrategy)[keyof typeof TypesResourceStrategy];

package/src/enums/index.ts

@@ -1,4 +1,24 @@
+import { CallReportingStatus } from './CallReportingStatus/CallReportingStatus';
 import { ChatGatewayProvider } from './ChatGatewayProvider/ChatGatewayPrivider';
+import { MemberStopCause } from './MemberStopCause/MemberStopCause';
+import {
+	QueueStrategy,
+	QueueStrategyList,
+} from './QueueStrategy/QueueStrategy';
+import { QueueType, QueueTypeName } from './QueueType/QueueType';
 import { RelativeDatetimeValue } from './RelativeDatetimeValue/RelativeDatetimeValue';
+import { TimeBaseScore } from './TimeBaseScore/TimeBaseScore';
+import { TypesResourceStrategy } from './TypesResourceStrategy/TypesResourceStrategy';
 
-export { ChatGatewayProvider, RelativeDatetimeValue };
+export {
+	CallReportingStatus,
+	ChatGatewayProvider,
+	MemberStopCause,
+	QueueStrategy,
+	QueueStrategyList,
+	QueueType,
+	QueueTypeName,
+	RelativeDatetimeValue,
+	TimeBaseScore,
+	TypesResourceStrategy,
+};

package/src/scripts/index.ts

@@ -1,5 +1,23 @@
 import convertDuration from './convertDuration/convertDuration';
 import downloadFile from './downloadFile/downloadFile';
 import { FileFormat } from './downloadFile/types/fileFormat.types';
+import {
+	isRelativeDatetimeValue,
+	normalizeDatetimeRange,
+	normalizeToTimestamp,
+} from './normalizeDatetime/normalizeDatetime';
 
-export { convertDuration, downloadFile, FileFormat };
+export type {
+	DatetimeRangeValue,
+	NormalizeDatetimeOptions,
+	NormalizeDatetimeValueParam,
+	RelativeDatetimeRoundOption,
+} from './normalizeDatetime/normalizeDatetime';
+export {
+	convertDuration,
+	downloadFile,
+	FileFormat,
+	isRelativeDatetimeValue,
+	normalizeDatetimeRange,
+	normalizeToTimestamp,
+};

package/src/scripts/normalizeDatetime/normalizeDatetime.ts

@@ -0,0 +1,132 @@
+import {
+	endOfMonth,
+	endOfToday,
+	endOfWeek,
+	startOfMonth,
+	startOfToday,
+	startOfWeek,
+} from 'date-fns';
+
+import { RelativeDatetimeValue } from '../../enums';
+
+export type RelativeDatetimeRoundOption =
+	| 'start'
+	| 'end'; /* for "from" or "to" */
+
+export type NormalizeDatetimeValueParam =
+	| RelativeDatetimeValue
+	| number
+	| string
+	| null
+	| undefined;
+
+export type NormalizeDatetimeOptions = {
+	round?: RelativeDatetimeRoundOption;
+};
+
+export const isRelativeDatetimeValue = (
+	value: unknown,
+): value is RelativeDatetimeValue => {
+	return (
+		typeof value === 'string' &&
+		(Object.values(RelativeDatetimeValue) as string[]).includes(value)
+	);
+};
+
+const convertRelativeDatetimeToTimestamp = (
+	relativeValue: RelativeDatetimeValue,
+	options?: NormalizeDatetimeOptions,
+): number => {
+	if (options?.round === 'end') {
+		switch (relativeValue) {
+			case RelativeDatetimeValue.Today:
+				return endOfToday().getTime();
+			case RelativeDatetimeValue.ThisWeek:
+				return endOfWeek(Date.now(), {
+					weekStartsOn: 1,
+				}).getTime();
+			case RelativeDatetimeValue.ThisMonth:
+				return endOfMonth(Date.now()).getTime();
+			default:
+				return Date.now();
+		}
+	}
+	switch (relativeValue) {
+		case RelativeDatetimeValue.Today:
+			return startOfToday().getTime();
+		case RelativeDatetimeValue.ThisWeek:
+			return startOfWeek(Date.now(), {
+				weekStartsOn: 1,
+			}).getTime();
+		case RelativeDatetimeValue.ThisMonth:
+			return startOfMonth(Date.now()).getTime();
+		default:
+			return Date.now();
+	}
+};
+
+export const normalizeToTimestamp = (
+	value?: NormalizeDatetimeValueParam,
+	options: NormalizeDatetimeOptions = {},
+): number => {
+	if (value == null) {
+		return 0;
+	}
+	if (typeof value === 'number') {
+		return value;
+	}
+	if (isRelativeDatetimeValue(value)) {
+		return convertRelativeDatetimeToTimestamp(value, options);
+	}
+	if (typeof value === 'string') {
+		if (+value) {
+			return +value;
+		}
+		return 0;
+	}
+	return Date.now();
+};
+
+export type DatetimeRangeValue = {
+	from?: NormalizeDatetimeValueParam;
+	to?: NormalizeDatetimeValueParam;
+};
+
+export const isDatetimeRangeValue = (
+	value: unknown,
+): value is DatetimeRangeValue =>
+	typeof value === 'object' &&
+	value !== null &&
+	('from' in value || 'to' in value);
+
+export const normalizeDatetimeRange = (
+	value?: NormalizeDatetimeValueParam | DatetimeRangeValue,
+): DatetimeRangeValue | undefined => {
+	if (value == null || value === '') {
+		return undefined;
+	}
+	if (isDatetimeRangeValue(value)) {
+		return {
+			from:
+				value.from == null || value.from === ''
+					? undefined
+					: normalizeToTimestamp(value.from, {
+							round: 'start',
+						}),
+			to:
+				value.to == null || value.to === ''
+					? undefined
+					: normalizeToTimestamp(value.to, {
+							round: 'end',
+						}),
+		};
+	}
+	return {
+		from: normalizeToTimestamp(value, {
+			round: 'start',
+		}),
+		to: normalizeToTimestamp(value, {
+			round: 'end',
+		}),
+	};
+};

package/src/validations/_shared/isFilled.ts

@@ -0,0 +1,15 @@
+/**
+ * @description
+ * Vuelidate's `required` semantics, preserved so migrated forms keep behaving
+ * the same: `{}` and `[]` count as empty, but `0` and `false` are filled.
+ *
+ * Getting this wrong is silent — a queue's `priority: 0` or `enabled: false`
+ * would start failing a required check that never fired before.
+ */
+export const isFilled = (value: unknown): boolean => {
+	if (value === null || value === undefined) return false;
+	if (Array.isArray(value)) return value.length > 0;
+	if (value instanceof Date) return !Number.isNaN(value.getTime());
+	if (typeof value === 'object') return Object.keys(value).length > 0;
+	return String(value).length > 0;
+};

package/src/validations/_shared/lookup.validations.ts

@@ -1,5 +1,8 @@
 import { z } from 'zod';
 
+import { i18nIssue } from './i18nIssue';
+import { isFilled } from './isFilled';
+
 export const lookupSchema = z.object({
 	id: z.string().optional(),
 	name: z.string().optional(),
@@ -9,3 +12,28 @@ export const requiredLookupSchema = z.object({
 	id: z.string().min(1),
 	name: z.string().optional(),
 });
+
+/**
+ * @description
+ * A lookup whose `id` may arrive as a number. Several call-center endpoints
+ * return numeric ids, and validating those against `lookupSchema`'s
+ * string-only `id` would fail a field the user filled in correctly.
+ */
+export const flexibleLookupSchema = z.object({
+	id: z
+		.union([
+			z.string(),
+			z.number(),
+		])
+		.optional(),
+	name: z.string().optional(),
+});
+
+/**
+ * The same, but required — reproducing Vuelidate's `required` on a lookup,
+ * which treated an empty object as missing.
+ */
+export const filledLookupSchema = flexibleLookupSchema.refine(
+	(value) => isFilled(value),
+	i18nIssue('required'),
+);

package/src/validations/_shared/variablePair.validations.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+/**
+ * @description
+ * Queues and queue members both hold user-defined variables as an editable
+ * list of pairs, while the wire format is a plain map. The api modules convert
+ * between the two; this is the form-side shape.
+ */
+export const variablePairSchema = z.object({
+	key: z.string(),
+	value: z.string(),
+});
+
+/**
+ * The form-side pair, for the components that edit the list. Inferred from the
+ * schema so it cannot drift from what the api modules convert against.
+ */
+export type VariablePair = z.infer<typeof variablePairSchema>;

package/src/validations/index.ts

@@ -1,5 +1,6 @@
 export * from './_shared/duration.validations';
 export * from './_shared/lookup.validations';
+export * from './_shared/variablePair.validations';
 export * from './auditForm/auditForm.validations';
 export * from './bucket/bucket.validations';
 export * from './calendar/calendar.validations';
@@ -15,6 +16,17 @@ export * from './contactGroup/contactGroup.validations';
 export * from './contactGroupCondition/contactGroupCondition.validations';
 export * from './OAuth/OAuth.validations';
 export * from './onlineSkill/onlineSkill.validations';
+export * from './queue/queue.rules';
+export * from './queue/queue.validations';
+export * from './queue/queueAmd.validations';
+export * from './queue/queuePayload.validations';
+export * from './queue/taskProcessing.validations';
+export * from './queueBucket/queueBucket.validations';
+export * from './queueHook/queueHook.validations';
+export * from './queueMember/memberCommunication.validations';
+export * from './queueMember/queueMember.validations';
+export * from './queueResGroup/queueResGroup.validations';
+export * from './queueSkill/queueSkill.validations';
 export * from './sla/sla.validations';
 export * from './slaCondition/slaCondition.validations';
 export * from './types';