@webitel/api-services 26.8.70 → 26.8.71

package/package.json

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

package/src/scripts/convertTimeUnits/__tests__/convertTimeUnits.spec.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+
+import { minToSec, secToMin } from '../convertTimeUnits';
+
+describe('convertTimeUnits', () => {
+	it('converts minutes to seconds', () => {
+		expect(minToSec(0)).toBe(0);
+		expect(minToSec(540)).toBe(32400);
+	});
+
+	it('converts seconds to minutes', () => {
+		expect(secToMin(0)).toBe(0);
+		expect(secToMin(32400)).toBe(540);
+	});
+
+	it('round-trips a time of day', () => {
+		expect(secToMin(minToSec(1439))).toBe(1439);
+	});
+});

package/src/scripts/convertTimeUnits/convertTimeUnits.ts

@@ -0,0 +1,3 @@
+export const minToSec = (min: number) => min * 60;
+
+export const secToMin = (sec: number) => sec / 60;

package/src/scripts/index.ts

@@ -1,4 +1,5 @@
 import convertDuration from './convertDuration/convertDuration';
+import { minToSec, secToMin } from './convertTimeUnits/convertTimeUnits';
 import downloadFile from './downloadFile/downloadFile';
 import { FileFormat } from './downloadFile/types/fileFormat.types';
 import {
@@ -18,6 +19,8 @@ export {
 	downloadFile,
 	FileFormat,
 	isRelativeDatetimeValue,
+	minToSec,
 	normalizeDatetimeRange,
 	normalizeToTimestamp,
+	secToMin,
 };

package/src/validations/_shared/timeRange.validations.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+
+import { i18nIssue } from './i18nIssue';
+
+export const dayMinuteSchema = z
+	.number()
+	.int()
+	.refine((value) => value >= 0 && value < 24 * 60, i18nIssue('hourRange'));
+
+export type TimeRange = {
+	start: number;
+	end: number;
+};
+
+export type TimeRangeError = {
+	index: number;
+	prop: string;
+	key: string;
+};
+
+const RANGE_PROPS = [
+	'start',
+	'end',
+] as const;
+
+const addRangeIssue = (
+	ctx: z.RefinementCtx,
+	key: string,
+	...path: number[]
+) => {
+	RANGE_PROPS.forEach((prop) => {
+		ctx.addIssue({
+			code: 'custom',
+			path: [
+				...path,
+				prop,
+			],
+			...i18nIssue(key),
+		});
+	});
+};
+
+export const refineTimeRangeStartLessThanEnd = (
+	item: TimeRange,
+	ctx: z.RefinementCtx,
+) => {
+	if (item.start >= item.end) addRangeIssue(ctx, 'timerangeStartLessThanEnd');
+};
+
+export const timeRangeSchema = z
+	.object({
+		start: dayMinuteSchema,
+		end: dayMinuteSchema,
+	})
+	.superRefine(refineTimeRangeStartLessThanEnd);
+
+const isIntersecting = (a: TimeRange, b: TimeRange) =>
+	a.start <= b.end && b.start <= a.end;
+
+export const refineTimeRangesNotIntersect =
+	<T extends TimeRange>(groupBy?: (item: T) => unknown) =>
+	(items: T[], ctx: z.RefinementCtx) => {
+		items.forEach((item, index) => {
+			const hasIntersection = items.some(
+				(other, otherIndex) =>
+					otherIndex !== index &&
+					groupBy?.(item) === groupBy?.(other) &&
+					isIntersecting(item, other),
+			);
+
+			if (hasIntersection) addRangeIssue(ctx, 'timerangeNotIntersect', index);
+		});
+	};
+
+export const getTimeRangeErrors = (
+	schema: z.ZodType,
+	items: unknown,
+): TimeRangeError[] => {
+	const result = schema.safeParse(items);
+
+	if (result.success) return [];
+
+	return result.error.issues.flatMap((issue) => {
+		const [index, prop] = issue.path;
+		const key = issue.code === 'custom' ? issue.params?.i18nKey : undefined;
+
+		if (
+			typeof index !== 'number' ||
+			typeof prop !== 'string' ||
+			typeof key !== 'string'
+		) {
+			return [];
+		}
+
+		return [
+			{
+				index,
+				prop,
+				key,
+			},
+		];
+	});
+};

package/src/validations/calendar/__tests__/calendar.validations.spec.ts

@@ -4,7 +4,7 @@ import type { z } from 'zod';
 import * as validationsIndex from '../../index';
 import {
 	calendarSchema,
-	getCalendarDayRangeIssues,
+	getCalendarDayRangeErrors,
 } from '../calendar.validations';
 
 /** custom rules carry their message key in params, see `i18nIssue` */
@@ -668,7 +668,7 @@ describe('validations barrel export', () => {
 	});
 });
 
-describe('getCalendarDayRangeIssues', () => {
+describe('getCalendarDayRangeErrors', () => {
 	const row = (day: number, start: number, end: number) => ({
 		day,
 		disabled: false,
@@ -678,7 +678,7 @@ describe('getCalendarDayRangeIssues', () => {
 
 	it('reports nothing for valid rows', () => {
 		expect(
-			getCalendarDayRangeIssues([
+			getCalendarDayRangeErrors([
 				row(0, 540, 541),
 				row(0, 600, 660),
 				row(1, 540, 1200),
@@ -688,7 +688,7 @@ describe('getCalendarDayRangeIssues', () => {
 
 	it('reports both ends of a row whose start is not before its end', () => {
 		expect(
-			getCalendarDayRangeIssues([
+			getCalendarDayRangeErrors([
 				row(0, 600, 540),
 			]),
 		).toEqual([
@@ -706,15 +706,15 @@ describe('getCalendarDayRangeIssues', () => {
 	});
 
 	it('reports every row of an overlap on the same day', () => {
-		const issues = getCalendarDayRangeIssues([
+		const errors = getCalendarDayRangeErrors([
 			row(0, 540, 720),
 			row(0, 600, 780),
 		]);
 
-		expect(issues.every(({ key }) => key === 'timerangeNotIntersect')).toBe(
+		expect(errors.every(({ key }) => key === 'timerangeNotIntersect')).toBe(
 			true,
 		);
-		expect(issues.map(({ index, prop }) => `${index}.${prop}`).sort()).toEqual([
+		expect(errors.map(({ index, prop }) => `${index}.${prop}`).sort()).toEqual([
 			'0.end',
 			'0.start',
 			'1.end',
@@ -724,7 +724,7 @@ describe('getCalendarDayRangeIssues', () => {
 
 	it('does not treat the same hours on different days as an overlap', () => {
 		expect(
-			getCalendarDayRangeIssues([
+			getCalendarDayRangeErrors([
 				row(0, 540, 720),
 				row(2, 540, 720),
 			]),
@@ -733,7 +733,7 @@ describe('getCalendarDayRangeIssues', () => {
 
 	it('reports a minute outside the day', () => {
 		expect(
-			getCalendarDayRangeIssues([
+			getCalendarDayRangeErrors([
 				row(0, 0, 24 * 60),
 			]),
 		).toEqual([

package/src/validations/calendar/calendar.validations.ts

@@ -1,67 +1,14 @@
 import type { EngineCalendar } from '@webitel/api-services/gen/models';
 import { z } from 'zod';
-import { i18nIssue } from '../_shared/i18nIssue';
 import { requiredLookupSchema } from '../_shared/lookup.validations';
+import {
+	dayMinuteSchema,
+	getTimeRangeErrors,
+	refineTimeRangeStartLessThanEnd,
+	refineTimeRangesNotIntersect,
+} from '../_shared/timeRange.validations';
 import type { ZodShape } from '../types';
 
-const HOUR_RANGE_KEY = 'hourRange';
-const TIMERANGE_START_LESS_THAN_END_KEY = 'timerangeStartLessThanEnd';
-const TIMERANGE_NOT_INTERSECT_KEY = 'timerangeNotIntersect';
-
-/** Legacy hourRange: value >= 0 && value < 1440 */
-const dayMinuteSchema = z
-	.number()
-	.int()
-	.refine((value) => value >= 0 && value < 24 * 60, i18nIssue(HOUR_RANGE_KEY));
-
-type AcceptOfDayUi = {
-	day: number;
-	start: number;
-	end: number;
-};
-
-const getIntersectingIndices = (items: AcceptOfDayUi[]) => {
-	const indices = new Set<number>();
-	const indicesByDay = new Map<number, number[]>();
-
-	items.forEach((item, index) => {
-		const dayIndices = indicesByDay.get(item.day) ?? [];
-		dayIndices.push(index);
-		indicesByDay.set(item.day, dayIndices);
-	});
-
-	indicesByDay.forEach((dayIndices) => {
-		const ranges: Array<{
-			start: number;
-			end: number;
-			index: number;
-		}> = [];
-
-		dayIndices.forEach((index) => {
-			const current = items[index];
-
-			ranges.forEach((range) => {
-				if (
-					(current.start >= range.start && current.end <= range.end) ||
-					(current.start <= range.start && current.end >= range.start) ||
-					(current.start <= range.end && current.end >= range.end)
-				) {
-					indices.add(index);
-					indices.add(range.index);
-				}
-			});
-
-			ranges.push({
-				start: current.start,
-				end: current.end,
-				index,
-			});
-		});
-	});
-
-	return indices;
-};
-
 /** UI shape: minutes as `start`/`end` (API maps to startTimeOfDay/endTimeOfDay). */
 const acceptOfDayUiSchema = z
 	.object({
@@ -70,54 +17,11 @@ const acceptOfDayUiSchema = z
 		start: dayMinuteSchema,
 		end: dayMinuteSchema,
 	})
-	.superRefine((item, ctx) => {
-		if (item.start >= item.end) {
-			ctx.addIssue({
-				code: 'custom',
-				path: [
-					'start',
-				],
-				...i18nIssue(TIMERANGE_START_LESS_THAN_END_KEY),
-			});
-			ctx.addIssue({
-				code: 'custom',
-				path: [
-					'end',
-				],
-				...i18nIssue(TIMERANGE_START_LESS_THAN_END_KEY),
-			});
-		}
-	});
+	.superRefine(refineTimeRangeStartLessThanEnd);
 
 const acceptsOfDayUiArraySchema = z
 	.array(acceptOfDayUiSchema)
-	.superRefine((items, ctx) => {
-		getIntersectingIndices(items).forEach((index) => {
-			ctx.addIssue({
-				code: 'custom',
-				path: [
-					index,
-					'start',
-				],
-				...i18nIssue(TIMERANGE_NOT_INTERSECT_KEY),
-			});
-			ctx.addIssue({
-				code: 'custom',
-				path: [
-					index,
-					'end',
-				],
-				...i18nIssue(TIMERANGE_NOT_INTERSECT_KEY),
-			});
-		});
-	});
-
-export type CalendarDayRangeIssue = {
-	index: number;
-	prop: string;
-	/** message key, resolve as `validation.<key>` */
-	key: string;
-};
+	.superRefine(refineTimeRangesNotIntersect((item) => item.day));
 
 /**
  * The same rules as the card schema, reported per row so a form can mark the
@@ -127,33 +31,8 @@ export type CalendarDayRangeIssue = {
  * verdicts (overlapping ranges) are only re-derived by a full `$validate()`,
  * so a row the user has not touched keeps a message that is no longer true.
  */
-export const getCalendarDayRangeIssues = (
-	items: unknown,
-): CalendarDayRangeIssue[] => {
-	const result = acceptsOfDayUiArraySchema.safeParse(items);
-
-	if (result.success) return [];
-
-	return result.error.issues.flatMap((issue) => {
-		const [index, prop] = issue.path;
-		const key =
-			issue.code === 'custom' && typeof issue.params?.i18nKey === 'string'
-				? issue.params.i18nKey
-				: undefined;
-
-		if (typeof index !== 'number' || typeof prop !== 'string' || !key) {
-			return [];
-		}
-
-		return [
-			{
-				index,
-				prop,
-				key,
-			},
-		];
-	});
-};
+export const getCalendarDayRangeErrors = (items: unknown) =>
+	getTimeRangeErrors(acceptsOfDayUiArraySchema, items);
 
 export const calendarExceptSchema = z.object({
 	name: z.string().min(1),

package/src/validations/index.ts

@@ -3,6 +3,7 @@ export * from './_shared/duration.validations';
 export * from './_shared/i18nIssue';
 export * from './_shared/lookup.validations';
 export * from './_shared/phoneNumber.validations';
+export * from './_shared/timeRange.validations';
 export * from './_shared/variablePair.validations';
 export * from './adjunctType/adjunctType.validations';
 export * from './agent/agent.validations';
@@ -44,6 +45,8 @@ export * from './queueMember/memberCommunication.validations';
 export * from './queueMember/queueMember.validations';
 export * from './queueResGroup/queueResGroup.validations';
 export * from './queueSkill/queueSkill.validations';
+export * from './resourceGroup/resourceGroup.validations';
+export * from './resourceInGroup/resourceInGroup.validations';
 export * from './sla/sla.validations';
 export * from './slaCondition/slaCondition.validations';
 export * from './team/team.validations';

package/src/validations/resourceGroup/__tests__/resourceGroup.validations.spec.ts

@@ -0,0 +1,191 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+import type { z } from 'zod';
+
+import {
+	getResourceGroupTimeRangeErrors,
+	resourceGroupSchema,
+} from '../resourceGroup.validations';
+
+const issueKey = (issue: z.core.$ZodIssue) =>
+	issue.code === 'custom' ? issue.params?.i18nKey : undefined;
+
+const communication = {
+	id: '1',
+	name: 'Phone',
+};
+
+const validInput = {
+	name: 'Group',
+	communication,
+	time: [
+		{
+			start: 540,
+			end: 1200,
+		},
+	],
+};
+
+describe('resourceGroupSchema', () => {
+	it('seeds a new group with one 9:00-20:00 range', () => {
+		expect(getDefaultsFromZodSchema(resourceGroupSchema, {})).toMatchObject({
+			description: '',
+			time: [
+				{
+					start: 540,
+					end: 1200,
+				},
+			],
+		});
+	});
+
+	it('accepts a filled group', () => {
+		expect(resourceGroupSchema.safeParse(validInput).success).toBe(true);
+	});
+
+	it('requires name and communication', () => {
+		const result = resourceGroupSchema.safeParse({
+			...validInput,
+			name: '',
+			communication: {},
+		});
+
+		const paths = result.error?.issues.map((issue) => issue.path.join('.'));
+		expect(paths).toContain('name');
+		expect(paths).toContain('communication');
+	});
+
+	it('requires at least one time range', () => {
+		const result = resourceGroupSchema.safeParse({
+			...validInput,
+			time: [],
+		});
+
+		expect(result.success).toBe(false);
+	});
+
+	it('rejects a range that starts after it ends', () => {
+		const result = resourceGroupSchema.safeParse({
+			...validInput,
+			time: [
+				{
+					start: 600,
+					end: 540,
+				},
+			],
+		});
+
+		expect(result.error?.issues.map(issueKey)).toContain(
+			'timerangeStartLessThanEnd',
+		);
+	});
+
+	it('rejects intersecting ranges', () => {
+		const result = resourceGroupSchema.safeParse({
+			...validInput,
+			time: [
+				{
+					start: 540,
+					end: 720,
+				},
+				{
+					start: 600,
+					end: 800,
+				},
+			],
+		});
+
+		expect(result.error?.issues.map(issueKey)).toContain(
+			'timerangeNotIntersect',
+		);
+	});
+});
+
+describe('getResourceGroupTimeRangeErrors', () => {
+	it('returns nothing for valid ranges', () => {
+		expect(
+			getResourceGroupTimeRangeErrors([
+				{
+					start: 540,
+					end: 600,
+				},
+				{
+					start: 700,
+					end: 800,
+				},
+			]),
+		).toEqual([]);
+	});
+
+	it('reports a reversed range on both its ends', () => {
+		expect(
+			getResourceGroupTimeRangeErrors([
+				{
+					start: 600,
+					end: 540,
+				},
+			]),
+		).toEqual([
+			{
+				index: 0,
+				prop: 'start',
+				key: 'timerangeStartLessThanEnd',
+			},
+			{
+				index: 0,
+				prop: 'end',
+				key: 'timerangeStartLessThanEnd',
+			},
+		]);
+	});
+
+	it('reports both ends of every intersecting range', () => {
+		const errors = getResourceGroupTimeRangeErrors([
+			{
+				start: 540,
+				end: 720,
+			},
+			{
+				start: 1000,
+				end: 1100,
+			},
+			{
+				start: 600,
+				end: 800,
+			},
+		]);
+
+		expect(errors).toEqual(
+			expect.arrayContaining([
+				{
+					index: 0,
+					prop: 'start',
+					key: 'timerangeNotIntersect',
+				},
+				{
+					index: 2,
+					prop: 'end',
+					key: 'timerangeNotIntersect',
+				},
+			]),
+		);
+		expect(errors.some(({ index }) => index === 1)).toBe(false);
+	});
+
+	it('reports a minute outside the day', () => {
+		expect(
+			getResourceGroupTimeRangeErrors([
+				{
+					start: 0,
+					end: 1440,
+				},
+			]),
+		).toEqual([
+			{
+				index: 0,
+				prop: 'end',
+				key: 'hourRange',
+			},
+		]);
+	});
+});

package/src/validations/resourceGroup/resourceGroup.validations.ts

@@ -0,0 +1,36 @@
+import type { EngineOutboundResourceGroup } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+import { filledLookupSchema } from '../_shared/lookup.validations';
+import {
+	getTimeRangeErrors,
+	refineTimeRangesNotIntersect,
+	type TimeRange,
+	timeRangeSchema,
+} from '../_shared/timeRange.validations';
+import type { ZodShape } from '../types';
+
+const timeRangesUiArraySchema = z
+	.array(timeRangeSchema)
+	.min(1)
+	.superRefine(refineTimeRangesNotIntersect());
+
+export const getResourceGroupTimeRangeErrors = (items: unknown) =>
+	getTimeRangeErrors(timeRangesUiArraySchema, items);
+
+export const getDefaultResourceGroupTimeRange = (): TimeRange => ({
+	start: 9 * 60,
+	end: 20 * 60,
+});
+
+export const resourceGroupSchema = z.object<
+	ZodShape<EngineOutboundResourceGroup> & {
+		time?: z.ZodType;
+	}
+>({
+	name: z.string().min(1),
+	communication: filledLookupSchema,
+	description: z.string().optional().default(''),
+	time: timeRangesUiArraySchema.default(() => [
+		getDefaultResourceGroupTimeRange(),
+	]),
+});

package/src/validations/resourceInGroup/__tests__/resourceInGroup.validations.spec.ts

@@ -0,0 +1,38 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { resourceInGroupSchema } from '../resourceInGroup.validations';
+
+const resource = {
+	id: '1',
+	name: 'Gateway',
+};
+
+describe('resourceInGroupSchema', () => {
+	it('seeds a new resource with priority 0', () => {
+		expect(getDefaultsFromZodSchema(resourceInGroupSchema, {})).toMatchObject({
+			priority: 0,
+			reserveResource: {},
+		});
+	});
+
+	it('requires a resource', () => {
+		const result = resourceInGroupSchema.safeParse({
+			resource: {},
+		});
+
+		expect(result.error?.issues.map((issue) => issue.path.join('.'))).toContain(
+			'resource',
+		);
+	});
+
+	it('lets priority and reserve resource be cleared', () => {
+		expect(
+			resourceInGroupSchema.safeParse({
+				resource,
+				priority: null,
+				reserveResource: null,
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/resourceInGroup/resourceInGroup.validations.ts

@@ -0,0 +1,16 @@
+import type { EngineOutboundResourceInGroup } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+import { clearableNumberSchema } from '../_shared/clearableNumber.validations';
+import {
+	filledLookupSchema,
+	flexibleLookupSchema,
+} from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const resourceInGroupSchema = z.object<
+	ZodShape<EngineOutboundResourceInGroup>
+>({
+	resource: filledLookupSchema,
+	reserveResource: flexibleLookupSchema.nullish().default({}),
+	priority: clearableNumberSchema.default(0),
+});