@webitel/api-services 1.0.10 → 1.0.12

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

@@ -0,0 +1,184 @@
+import { getWorkingConditionService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers';
+import type {
+	AddItemParams,
+	ApiParams,
+	DeleteItemParams,
+	GetItemParams,
+	UpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'name',
+	'description',
+	'workdayHours',
+	'workdayPerMonth',
+	'pauseDuration',
+	'vacation',
+	'pauseTemplate',
+	'sickLeaves',
+	'shiftTemplate',
+	'daysOff',
+	'createdAt',
+	'createdBy',
+	'domainId',
+	'id',
+	'updatedAt',
+	'updatedBy',
+];
+
+/**
+ * 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, [
+		merge(getDefaultGetParams()),
+	]);
+
+	try {
+		const response =
+			await getWorkingConditionService().workingConditionServiceSearchWorkingCondition(
+				{
+					page,
+					size,
+					q,
+					sort,
+					fields,
+				},
+			);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getWorkingCondition = async ({ itemId: id }: GetItemParams) => {
+	try {
+		const response =
+			await getWorkingConditionService().workingConditionServiceReadWorkingCondition(
+				String(id),
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addWorkingCondition = async ({ itemInstance }: AddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getWorkingConditionService().workingConditionServiceCreateWorkingCondition(
+				{
+					item: {
+						...item,
+					},
+				},
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateWorkingCondition = async ({
+	itemInstance,
+	itemId: id,
+}: UpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getWorkingConditionService().workingConditionServiceUpdateWorkingCondition(
+				String(id),
+				{
+					item: {
+						...item,
+					},
+				},
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteWorkingCondition = async ({ id }: DeleteItemParams) => {
+	try {
+		const response =
+			await getWorkingConditionService().workingConditionServiceDeleteWorkingCondition(
+				String(id),
+			);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getWorkingConditionsLookup = (
+	params: Parameters<typeof getWorkingConditionsList>[0],
+) =>
+	getWorkingConditionsList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+		],
+	});
+
+export const WorkingConditionsAPI = {
+	getList: getWorkingConditionsList,
+	get: getWorkingCondition,
+	add: addWorkingCondition,
+	update: updateWorkingCondition,
+	delete: deleteWorkingCondition,
+	getLookup: getWorkingConditionsLookup,
+};

package/src/api/clients/workspaceWidgets/workspaceWidgets.ts

@@ -0,0 +1,73 @@
+import { getUserHelperService } from '../../../gen-wire';
+import { convertDuration } from '../../../scripts';
+import {
+	applyTransform,
+	merge,
+	notify,
+	snakeToCamel,
+} from '../../transformers';
+import type { ApiParams } from '../_shared/types';
+
+/**
+ * The agent workspace's activity widget bar: one flat stats object, with the
+ * duration fields pre-formatted for display.
+ */
+const getWorkspaceWidgets = async () => {
+	const defaultObject = {
+		callInbound: 0,
+		callHandled: 0,
+		callMissed: 0,
+		callManual: 0,
+		callQueueMissed: 0,
+		callInboundQueue: 0,
+		callDialerQueue: 0,
+		avgHoldSec: 0,
+		avgTalkSec: 0,
+		occupancy: 0,
+		utilization: 0,
+		chatAccepts: 0,
+		chatAht: 0,
+		scoreCount: 0,
+		scoreRequiredAvg: 0,
+		sumTalkSec: 0,
+		processing: 0,
+		available: 0,
+		voiceMail: 0,
+		queueTalkSec: 0,
+		taskAccepts: 0,
+	};
+
+	const responseHandler = (stats: ApiParams) => ({
+		...stats,
+		avgHoldSec: convertDuration(stats.avgHoldSec),
+		avgTalkSec: convertDuration(stats.avgTalkSec),
+		occupancy: `${stats.occupancy.toFixed(2)}%`,
+		utilization: `${stats.utilization.toFixed(2)}%`,
+		chatAht: convertDuration(stats.chatAht),
+		sumTalkSec: convertDuration(stats.sumTalkSec),
+		processing: convertDuration(stats.processing),
+		voiceMail: convertDuration(stats.voiceMail),
+		queueTalkSec: convertDuration(stats.queueTalkSec),
+		available: convertDuration(stats.available),
+
+		// left unformatted on purpose: https://webitel.atlassian.net/browse/DEV-4691?focusedCommentId=637940
+		scoreRequiredAvg: stats.scoreRequiredAvg,
+	});
+
+	try {
+		const response = await getUserHelperService().activityWorkspaceWidget();
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+			responseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const WorkspaceWidgetsAPI = {
+	getWidgets: getWorkspaceWidgets,
+};

package/src/api/clients//321/201ontacts/contactChatMessagesHistory.ts

@@ -1,9 +1,5 @@
-import { ContactsChatCatalogApiFactory } from 'webitel-sdk';
-import {
-	getDefaultGetListResponse,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+import { getContactsChatCatalog } from '../../../gen-wire';
+import { getDefaultGetListResponse } from '../../defaults';
 import {
 	applyTransform,
 	merge,
@@ -12,15 +8,6 @@ import {
 } from '../../transformers';
 import type { ApiId, ApiParams } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const contactChatService = ContactsChatCatalogApiFactory(
-	configuration,
-	'',
-	instance,
-);
-
 const getChat = async ({
 	contactId,
 	chatId,
@@ -45,10 +32,11 @@ const getChat = async ({
 	};
 
 	try {
-		const response = await contactChatService.getContactChatHistory(
-			String(contactId),
-			String(chatId),
-		);
+		const response =
+			await getContactsChatCatalog().contactsChatCatalogGetContactChatHistory(
+				String(contactId),
+				String(chatId),
+			);
 		const { messages, peers } = applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -95,13 +83,14 @@ const getAllMessages = async (params: ApiParams) => {
 	const { contactId, page, size } = params;
 
 	try {
-		const response = await contactChatService.getContactChatHistory2(
-			contactId,
-			undefined,
-			undefined,
-			size,
-			page || 1,
-		);
+		const response =
+			await getContactsChatCatalog().contactsChatCatalogGetContactChatHistory2(
+				contactId,
+				{
+					size,
+					page: page || 1,
+				},
+			);
 		const { messages, peers, chats, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),

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

@@ -453,6 +453,91 @@ describe('calendarSchema', () => {
 				).toBe(true);
 			}
 		});
+
+		it('rejects overlapping special intervals on the same day', () => {
+			const result = calendarSchema.safeParse({
+				...minimalValidInput,
+				specials: [
+					{
+						day: 1,
+						disabled: false,
+						start: 540,
+						end: 720,
+					},
+					{
+						day: 1,
+						disabled: false,
+						start: 600,
+						end: 780,
+					},
+				],
+			});
+
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				const intersectIssues = result.error.issues.filter(
+					(issue) => issueKey(issue) === 'timerangeNotIntersect',
+				);
+				expect(intersectIssues.length).toBeGreaterThan(0);
+				expect(
+					intersectIssues.some(
+						(issue) => issue.path.join('.') === 'specials.0.start',
+					),
+				).toBe(true);
+				expect(
+					intersectIssues.some(
+						(issue) => issue.path.join('.') === 'specials.1.end',
+					),
+				).toBe(true);
+			}
+		});
+
+		it('accepts non-overlapping special intervals on the same day', () => {
+			const result = calendarSchema.safeParse({
+				...minimalValidInput,
+				specials: [
+					{
+						day: 1,
+						disabled: false,
+						start: 540,
+						end: 600,
+					},
+					{
+						day: 1,
+						disabled: false,
+						start: 660,
+						end: 720,
+					},
+				],
+			});
+
+			expect(result.success).toBe(true);
+		});
+
+		it('rejects a special entry with start greater than end', () => {
+			const result = calendarSchema.safeParse({
+				...minimalValidInput,
+				specials: [
+					{
+						day: 0,
+						disabled: false,
+						start: 720,
+						end: 600,
+					},
+				],
+			});
+
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				expect(
+					result.error.issues.some(
+						(issue) =>
+							issueKey(issue) === 'timerangeStartLessThanEnd' &&
+							issue.path.join('.') === 'specials.0.start',
+					),
+				).toBe(true);
+			}
+		});
 	});
 
 	describe('excepts', () => {

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

@@ -209,6 +209,6 @@ export const calendarSchema = z.object<
 	endAt: z.any().optional(),
 	expires: z.boolean().optional().default(false),
 	accepts: acceptsOfDayUiArraySchema.default(defaultAccepts),
-	specials: z.array(acceptOfDayUiSchema).default(defaultSpecials),
+	specials: acceptsOfDayUiArraySchema.default(defaultSpecials),
 	excepts: z.array(calendarExceptSchema).optional().default([]),
 });