@webitel/api-services 26.8.77 → 26.8.79

package/package.json

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

package/src/api/clients/agentWorkingConditions/agentWorkingConditions.ts

@@ -0,0 +1,74 @@
+import { getAgentWorkingConditionsService } from '../../../gen-wire';
+import {
+	applyTransform,
+	camelToSnake,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers';
+import type {
+	ApiParams,
+	GetItemParams,
+	UpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'workingCondition',
+	'pauseTemplate',
+];
+
+/**
+ * [Claude] WFM services wrap both request and response payloads in an `item` envelope.
+ */
+const itemResponseHandler = (response: ApiParams) => ({
+	...response.item,
+});
+
+const getAgentWorkingConditions = async ({ itemId: id }: GetItemParams) => {
+	try {
+		const response =
+			await getAgentWorkingConditionsService().agentWorkingConditionsServiceReadAgentWorkingConditions(
+				String(id),
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateAgentWorkingConditions = async ({
+	itemInstance,
+	itemId: id,
+}: UpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getAgentWorkingConditionsService().agentWorkingConditionsServiceUpdateAgentWorkingConditions(
+				String(id),
+				{
+					item,
+				},
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const AgentWorkingConditionsAPI = {
+	get: getAgentWorkingConditions,
+	update: updateAgentWorkingConditions,
+};

package/src/api/clients/index.ts

@@ -6,6 +6,7 @@ export * from './agentSkills/agentSkills';
 export * from './agents/agentAbsence';
 export * from './agents/agentChats';
 export * from './agents/agents';
+export * from './agentWorkingConditions/agentWorkingConditions';
 export * from './auditForms/auditForms';
 export * from './auditForms/auditRates';
 export * from './backendProfiles/backendProfiles';

package/src/api/clients/workingConditions/__tests__/workingConditions.spec.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const wireItem = {
+	id: '1',
+	name: 'FTE 1',
+	description: 'desc',
+	workday_hours: 9,
+	workdays_per_month: 20,
+	vacation: 24,
+	sick_leaves: 10,
+	days_off: 5,
+	pause_duration: 60,
+	pause_template: {
+		id: '7',
+		name: '30-15-15',
+	},
+	shift_template: {
+		id: '3',
+		name: 'Full time',
+	},
+	domain_id: '1',
+};
+
+const service = {
+	workingConditionServiceSearchWorkingCondition: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				items: [
+					wireItem,
+				],
+				next: true,
+			},
+		}),
+	),
+	workingConditionServiceReadWorkingCondition: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+	workingConditionServiceCreateWorkingCondition: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+	workingConditionServiceUpdateWorkingCondition: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+};
+
+vi.mock('../../../../gen-wire', async (importOriginal) => ({
+	...(await importOriginal<Record<string, unknown>>()),
+	getWorkingConditionService: () => service,
+}));
+
+const { WorkingConditionsAPI } = await import('../workingConditions');
+
+const formItem = {
+	id: '1',
+	name: 'FTE 1',
+	description: 'desc',
+	workdayHours: 9,
+	workdaysPerMonth: 20,
+	vacation: 24,
+	sickLeaves: 10,
+	daysOff: 5,
+	pauseDuration: 60,
+	pauseTemplate: {
+		id: '7',
+		name: '30-15-15',
+	},
+	shiftTemplate: null,
+	domainId: '1',
+	createdAt: '1',
+	_dirty: true,
+};
+
+describe('WorkingConditionsAPI', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('getList sends the search as `q`', async () => {
+		const { items, next } = await WorkingConditionsAPI.getList({
+			search: 'fte',
+			page: 2,
+			size: 10,
+		});
+
+		expect(
+			service.workingConditionServiceSearchWorkingCondition,
+		).toHaveBeenCalledWith(
+			expect.objectContaining({
+				q: 'fte*',
+				page: 2,
+				size: 10,
+			}),
+		);
+		expect(items[0].workdaysPerMonth).toBe(20);
+		expect(next).toBe(true);
+	});
+
+	it('get and update unwrap the `item` envelope', async () => {
+		const item = await WorkingConditionsAPI.get({
+			itemId: '1',
+		});
+		expect(item.pauseTemplate).toEqual(wireItem.pause_template);
+
+		const updated = await WorkingConditionsAPI.update({
+			itemId: '1',
+			itemInstance: formItem,
+		});
+		expect(updated.name).toBe('FTE 1');
+	});
+
+	it('add wraps the item and sends only the form fields', async () => {
+		await WorkingConditionsAPI.add({
+			itemInstance: formItem,
+		});
+
+		const [body] =
+			service.workingConditionServiceCreateWorkingCondition.mock.calls[0];
+		expect(body).toEqual({
+			item: {
+				name: 'FTE 1',
+				description: 'desc',
+				workday_hours: 9,
+				workdays_per_month: 20,
+				vacation: 24,
+				sick_leaves: 10,
+				days_off: 5,
+				pause_duration: 60,
+				pause_template: {
+					id: '7',
+					name: '30-15-15',
+				},
+				shift_template: null,
+			},
+		});
+	});
+
+	it('update sends the id separately and drops it from the item', async () => {
+		await WorkingConditionsAPI.update({
+			itemId: '1',
+			itemInstance: formItem,
+		});
+
+		const [id, body] =
+			service.workingConditionServiceUpdateWorkingCondition.mock.calls[0];
+		expect(id).toBe('1');
+		expect(body.item).not.toHaveProperty('id');
+		expect(body.item).not.toHaveProperty('domain_id');
+		expect(body.item).not.toHaveProperty('_dirty');
+	});
+});

package/src/api/clients/workingConditions/workingConditions.ts

@@ -1,12 +1,18 @@
-import { getWorkingConditionService } from '../../../gen-wire';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { workingConditionSchema } from '@webitel/api-services/validations';
+import {
+	getWorkingConditionService,
+	WorkingConditionServiceSearchWorkingConditionQueryParams,
+} from '../../../gen-wire';
 import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
+	starToSearch,
 } from '../../transformers';
 import type {
 	AddItemParams,
@@ -16,53 +22,37 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const fieldsToSend = [
-	'name',
-	'description',
-	'workdayHours',
-	'workdayPerMonth',
-	'pauseDuration',
-	'vacation',
-	'pauseTemplate',
-	'sickLeaves',
-	'shiftTemplate',
-	'daysOff',
-	'createdAt',
-	'createdBy',
-	'domainId',
-	'id',
-	'updatedAt',
-	'updatedBy',
-];
+const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+	workingConditionSchema,
+);
 
 /**
- * WFM services wrap both request and response payloads in an `item` envelope.
+ * [Claude] WFM services wrap both request and response payloads in an `item` envelope.
  */
 const itemResponseHandler = (response: ApiParams) => ({
 	...response.item,
 });
 
 const getWorkingConditionsList = async (params: ApiParams) => {
-	const {
-		search: q,
-		page,
-		size,
-		sort,
-		fields,
-	} = applyTransform(params, [
+	const requestParams = applyTransform(params, [
 		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		(params: ApiParams) => ({
+			...params,
+			q: params.q ?? params.search,
+		}),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(
+				WorkingConditionServiceSearchWorkingConditionQueryParams,
+			),
+		),
+		camelToSnake(),
 	]);
 
 	try {
 		const response =
 			await getWorkingConditionService().workingConditionServiceSearchWorkingCondition(
-				{
-					page,
-					size,
-					q,
-					sort,
-					fields,
-				},
+				requestParams,
 			);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
@@ -98,16 +88,14 @@ const getWorkingCondition = async ({ itemId: id }: GetItemParams) => {
 
 const addWorkingCondition = async ({ itemInstance }: AddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
 		const response =
 			await getWorkingConditionService().workingConditionServiceCreateWorkingCondition(
 				{
-					item: {
-						...item,
-					},
+					item,
 				},
 			);
 		return applyTransform(response.data, [
@@ -126,7 +114,7 @@ const updateWorkingCondition = async ({
 	itemId: id,
 }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
@@ -134,13 +122,12 @@ const updateWorkingCondition = async ({
 			await getWorkingConditionService().workingConditionServiceUpdateWorkingCondition(
 				String(id),
 				{
-					item: {
-						...item,
-					},
+					item,
 				},
 			);
 		return applyTransform(response.data, [
 			snakeToCamel(),
+			itemResponseHandler,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -163,9 +150,7 @@ const deleteWorkingCondition = async ({ id }: DeleteItemParams) => {
 	}
 };
 
-const getWorkingConditionsLookup = (
-	params: Parameters<typeof getWorkingConditionsList>[0],
-) =>
+const getWorkingConditionsLookup = (params: ApiParams) =>
 	getWorkingConditionsList({
 		...params,
 		fields: params.fields || [

package/src/validations/agent/agent.validations.ts

@@ -23,3 +23,13 @@ export const agentSchema = z.object<ZodShape<EngineAgent>>({
 	screenControl: z.boolean().optional().default(false),
 	allowSetScreenControl: z.boolean().optional(),
 });
+
+/**
+ * [Claude] WFM part of the agent card, stored apart from the agent itself
+ * (`/wfm/agents/{id}/conditions`). Merge it into {@link agentSchema} only
+ * when the user has a WFM license.
+ */
+export const agentWfmConditionsSchema = z.object({
+	workingCondition: filledLookupSchema,
+	pauseTemplate: flexibleLookupSchema.optional().default({}),
+});

package/src/validations/index.ts

@@ -62,3 +62,4 @@ export * from './types';
 export * from './user/user.validations';
 export * from './userToken/userToken.validations';
 export * from './variable/variable.validations';
+export * from './workingCondition/workingCondition.validations';

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

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+
+import { workingConditionSchema } from '../workingCondition.validations';
+
+const valid = {
+	name: 'FTE 1',
+	pauseTemplate: {
+		id: '1',
+		name: '30-15-15',
+	},
+};
+
+describe('workingConditionSchema', () => {
+	it('accepts a condition with only a name and a pause template', () => {
+		expect(workingConditionSchema.safeParse(valid).success).toBe(true);
+	});
+
+	it('requires a pause template', () => {
+		expect(
+			workingConditionSchema.safeParse({
+				name: 'FTE 1',
+			}).success,
+		).toBe(false);
+	});
+
+	it('keeps the workday duration optional and clearable', () => {
+		expect(
+			workingConditionSchema.safeParse({
+				...valid,
+				workdayHours: null,
+			}).success,
+		).toBe(true);
+	});
+
+	it('rejects a name longer than 250 symbols', () => {
+		expect(
+			workingConditionSchema.safeParse({
+				...valid,
+				name: 'a'.repeat(251),
+			}).success,
+		).toBe(false);
+	});
+
+	it.each([
+		[
+			'workdayHours',
+			25,
+		],
+		[
+			'workdaysPerMonth',
+			32,
+		],
+		[
+			'vacation',
+			366,
+		],
+		[
+			'sickLeaves',
+			366,
+		],
+		[
+			'daysOff',
+			366,
+		],
+		[
+			'pauseDuration',
+			1441,
+		],
+		[
+			'workdayHours',
+			-1,
+		],
+	])('rejects %s = %j', (field, value) => {
+		expect(
+			workingConditionSchema.safeParse({
+				...valid,
+				[field]: value,
+			}).success,
+		).toBe(false);
+	});
+});

package/src/validations/workingCondition/workingCondition.validations.ts

@@ -0,0 +1,25 @@
+import type { WfmWorkingCondition } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import {
+	filledLookupSchema,
+	flexibleLookupSchema,
+} from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+/** [Claude] an optional whole number the user may clear (`wt-input-number` emits `null`) */
+const optionalCountSchema = (max: number) =>
+	z.number().int().min(0).max(max).nullish();
+
+export const workingConditionSchema = z.object<ZodShape<WfmWorkingCondition>>({
+	name: z.string().min(1).max(250),
+	description: z.string().optional().default(''),
+	workdayHours: optionalCountSchema(24),
+	workdaysPerMonth: optionalCountSchema(31),
+	vacation: optionalCountSchema(365),
+	sickLeaves: optionalCountSchema(365),
+	daysOff: optionalCountSchema(365),
+	pauseDuration: optionalCountSchema(1440),
+	pauseTemplate: filledLookupSchema,
+	shiftTemplate: flexibleLookupSchema.nullish(),
+});