@webitel/api-services 26.8.66 → 26.8.68

package/package.json

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

package/src/api/clients/queues/__tests__/queueMembers.spec.ts

@@ -3,12 +3,14 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 const searchMemberInQueue = vi.fn();
 const resetMembersCount = vi.fn();
 const resetMembers = vi.fn();
+const searchMemberCommunication = vi.fn();
 
 vi.mock('../../../../gen-wire', () => ({
 	getMemberService: () => ({
 		searchMemberInQueue,
 		resetMembersCount,
 		resetMembers,
+		searchMemberCommunication,
 	}),
 }));
 
@@ -173,3 +175,68 @@ describe('QueueMembersAPI.getQuantity', () => {
 		).resolves.toBe(0);
 	});
 });
+
+describe('QueueMembersAPI.getCommunications', () => {
+	beforeEach(() => {
+		searchMemberCommunication.mockReset().mockResolvedValue({
+			data: {
+				items: [
+					{
+						id: '1',
+						destination: '380',
+					},
+				],
+				next: true,
+			},
+		});
+	});
+
+	it('requests one member of one queue with the sort and page', async () => {
+		await QueueMembersAPI.getCommunications({
+			parentId: 7,
+			memberId: 42,
+			page: 2,
+			size: 20,
+			sort: '-priority',
+		});
+
+		expect(searchMemberCommunication).toHaveBeenCalledWith('7', '42', {
+			page: 2,
+			size: 20,
+			sort: '-priority',
+			fields: undefined,
+		});
+	});
+
+	it('returns the items with the next flag', async () => {
+		const { items, next } = await QueueMembersAPI.getCommunications({
+			parentId: 7,
+			memberId: 42,
+		});
+
+		expect(items).toEqual([
+			{
+				id: '1',
+				destination: '380',
+			},
+		]);
+		expect(next).toBe(true);
+	});
+
+	/** an empty list comes back as `{}` */
+	it('defaults to an empty last page', async () => {
+		searchMemberCommunication.mockResolvedValue({
+			data: {},
+		});
+
+		await expect(
+			QueueMembersAPI.getCommunications({
+				parentId: 7,
+				memberId: 42,
+			}),
+		).resolves.toEqual({
+			items: [],
+			next: false,
+		});
+	});
+});

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

@@ -183,6 +183,43 @@ const getMembersList = async (params: ApiParams) => {
 	}
 };
 
+const getMemberCommunications = async ({
+	parentId,
+	memberId,
+	page,
+	size,
+	sort,
+	fields,
+}: ApiParams & {
+	parentId: ApiId;
+	memberId: ApiId;
+}) => {
+	try {
+		const response = await getMemberService().searchMemberCommunication(
+			String(parentId),
+			String(memberId),
+			{
+				page,
+				size,
+				sort,
+				fields,
+			},
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
 /**
  * Streamed CSV/XLSX export of the current filter set. Returns the raw axios
  * response with an unread Blob body — the caller passes it to the shared
@@ -518,6 +555,7 @@ const deleteMembersBulk = async ({
 
 export const QueueMembersAPI = {
 	getList: getMembersList,
+	getCommunications: getMemberCommunications,
 	exportMembers,
 	getQuantity: getMembersQuantity,
 	get: getMember,

package/src/validations/index.ts

@@ -46,6 +46,10 @@ export * from './queueResGroup/queueResGroup.validations';
 export * from './queueSkill/queueSkill.validations';
 export * from './sla/sla.validations';
 export * from './slaCondition/slaCondition.validations';
+export * from './team/team.validations';
+export * from './teamAgent/teamAgent.validations';
+export * from './teamFlow/teamFlow.validations';
+export * from './teamHook/teamHook.validations';
 export * from './typeExtension/typeExtension.validations';
 export * from './types';
 export * from './user/user.validations';

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

@@ -0,0 +1,85 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { teamSchema } from '../team.validations';
+
+const filledTeam = {
+	name: 'Support',
+	strategy: 'random',
+	maxNoAnswer: 3,
+	wrapUpTime: 15,
+	noAnswerDelayTime: 30,
+	taskAcceptTimeout: 30,
+	callTimeout: 60,
+	inviteChatTimeout: 30,
+};
+
+const issuePaths = (value: Record<string, unknown>) =>
+	teamSchema
+		.safeParse(value)
+		.error?.issues.map((issue) => issue.path.join('.')) ?? [];
+
+describe('teamSchema', () => {
+	it('seeds a new team with the defaults the form expects', () => {
+		expect(getDefaultsFromZodSchema(teamSchema, {})).toMatchObject({
+			name: '',
+			description: '',
+			strategy: '',
+			admin: [],
+			screenControl: false,
+			maxNoAnswer: 3,
+			wrapUpTime: 15,
+			noAnswerDelayTime: 30,
+			taskAcceptTimeout: 30,
+			callTimeout: 60,
+			inviteChatTimeout: 30,
+		});
+	});
+
+	it('requires a name and a strategy', () => {
+		const paths = issuePaths({
+			...filledTeam,
+			name: '',
+			strategy: '',
+		});
+
+		expect(paths).toContain('name');
+		expect(paths).toContain('strategy');
+	});
+
+	it('requires every timing parameter', () => {
+		const paths = issuePaths({
+			...filledTeam,
+			maxNoAnswer: null,
+			wrapUpTime: null,
+			noAnswerDelayTime: null,
+			taskAcceptTimeout: null,
+			callTimeout: null,
+			inviteChatTimeout: null,
+		});
+
+		expect(paths).toEqual(
+			expect.arrayContaining([
+				'maxNoAnswer',
+				'wrapUpTime',
+				'noAnswerDelayTime',
+				'taskAcceptTimeout',
+				'callTimeout',
+				'inviteChatTimeout',
+			]),
+		);
+	});
+
+	it('accepts a zero timing parameter', () => {
+		expect(
+			teamSchema.safeParse({
+				...filledTeam,
+				wrapUpTime: 0,
+			}).success,
+		).toBe(true);
+	});
+
+	it('accepts a filled team', () => {
+		expect(teamSchema.safeParse(filledTeam).success).toBe(true);
+	});
+});

package/src/validations/team/team.validations.ts

@@ -0,0 +1,20 @@
+import type { EngineAgentTeam } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { flexibleLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const teamSchema = z.object<ZodShape<EngineAgentTeam>>({
+	id: z.string().optional(),
+	name: z.string().min(1).default(''),
+	description: z.string().optional().default(''),
+	strategy: z.string().min(1).default(''),
+	admin: z.array(flexibleLookupSchema).optional().default([]),
+	screenControl: z.boolean().optional().default(false),
+	maxNoAnswer: z.number().default(3),
+	wrapUpTime: z.number().default(15),
+	noAnswerDelayTime: z.number().default(30),
+	taskAcceptTimeout: z.number().default(30),
+	callTimeout: z.number().default(60),
+	inviteChatTimeout: z.number().default(30),
+});

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

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+
+import { teamAgentSchema } from '../teamAgent.validations';
+
+describe('teamAgentSchema', () => {
+	it('requires an agent', () => {
+		expect(
+			teamAgentSchema.safeParse({
+				agent: {},
+			}).success,
+		).toBe(false);
+	});
+
+	it('accepts a picked agent', () => {
+		expect(
+			teamAgentSchema.safeParse({
+				agent: {
+					id: '1',
+					name: 'John',
+				},
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/teamAgent/teamAgent.validations.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+import { filledLookupSchema } from '../_shared/lookup.validations';
+
+export const teamAgentSchema = z.object({
+	agent: filledLookupSchema,
+});

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+
+import { teamFlowSchema } from '../teamFlow.validations';
+
+const issuePaths = (value: Record<string, unknown>) =>
+	teamFlowSchema
+		.safeParse(value)
+		.error?.issues.map((issue) => issue.path.join('.')) ?? [];
+
+describe('teamFlowSchema', () => {
+	it('requires a name and a flow schema', () => {
+		const paths = issuePaths({
+			name: '',
+			schema: {},
+		});
+
+		expect(paths).toContain('name');
+		expect(paths).toContain('schema');
+	});
+
+	it('accepts a filled flow', () => {
+		expect(
+			teamFlowSchema.safeParse({
+				name: 'Service',
+				schema: {
+					id: 1,
+					name: 'Flow',
+				},
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/teamFlow/teamFlow.validations.ts

@@ -0,0 +1,12 @@
+import type { EngineTeamTrigger } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { filledLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const teamFlowSchema = z.object<ZodShape<EngineTeamTrigger>>({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	schema: filledLookupSchema,
+	enabled: z.boolean().default(true),
+});

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+
+import { teamHookSchema } from '../teamHook.validations';
+
+const issuePaths = (value: Record<string, unknown>) =>
+	teamHookSchema
+		.safeParse(value)
+		.error?.issues.map((issue) => issue.path.join('.')) ?? [];
+
+describe('teamHookSchema', () => {
+	it('requires an event and a flow schema', () => {
+		const paths = issuePaths({
+			event: '',
+			schema: {},
+		});
+
+		expect(paths).toContain('event');
+		expect(paths).toContain('schema');
+	});
+
+	it('accepts a filled hook', () => {
+		expect(
+			teamHookSchema.safeParse({
+				event: 'agent_status',
+				schema: {
+					id: 1,
+					name: 'Flow',
+				},
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/teamHook/teamHook.validations.ts

@@ -0,0 +1,12 @@
+import type { EngineTeamHook } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { filledLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const teamHookSchema = z.object<ZodShape<EngineTeamHook>>({
+	event: z.string().min(1),
+	schema: filledLookupSchema,
+	properties: z.array(z.string()).optional(),
+	enabled: z.boolean().default(true),
+});