@webitel/api-services 1.0.10 → 1.0.11

package/src/api/clients/teamTriggers/teamFlows.ts

@@ -0,0 +1,194 @@
+import { getTeamTriggerService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	ApiId,
+	ApiParams,
+	NestedAddItemParams,
+	NestedDeleteItemParams,
+	NestedGetItemParams,
+	NestedPatchItemParams,
+	NestedUpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'name',
+	'schema',
+	'enabled',
+	'description',
+];
+
+const preRequestHandler = (parentId: ApiId) => (item: ApiParams) => ({
+	...item,
+	teamId: parentId,
+});
+
+const getTeamFlowsList = async (params: ApiParams) => {
+	const defaultObject = {
+		enabled: false,
+	};
+
+	const { page, size, search, sort, fields, id, enabled, parentId } =
+		applyTransform(params, [
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+		]);
+
+	try {
+		const response = await getTeamTriggerService().searchTeamTrigger(
+			String(parentId),
+			{
+				page,
+				size,
+				// the generated param is `q`; `search` is what the datalist store sends
+				q: search,
+				sort,
+				fields,
+				enabled,
+				id,
+			},
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				mergeEach(defaultObject),
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getTeamFlow = async ({ parentId, itemId: id }: NestedGetItemParams) => {
+	const defaultObject = {
+		name: '',
+		description: '',
+		enabled: false,
+		schema: {},
+	};
+
+	try {
+		const response = await getTeamTriggerService().readTeamTrigger(
+			String(parentId),
+			Number(id),
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addTeamFlow = async ({ parentId, itemInstance }: NestedAddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getTeamTriggerService().createTeamTrigger(
+			String(parentId),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchTeamFlow = async ({
+	parentId,
+	changes,
+	id,
+}: NestedPatchItemParams) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getTeamTriggerService().patchTeamTrigger(
+			String(parentId),
+			Number(id),
+			body,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateTeamFlow = async ({
+	parentId,
+	itemInstance,
+	itemId: id,
+}: NestedUpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getTeamTriggerService().updateTeamTrigger(
+			String(parentId),
+			Number(id),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteTeamFlow = async ({ parentId, id }: NestedDeleteItemParams) => {
+	try {
+		const response = await getTeamTriggerService().deleteTeamTrigger(
+			String(parentId),
+			Number(id),
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const TeamFlowsAPI = {
+	getList: getTeamFlowsList,
+	get: getTeamFlow,
+	add: addTeamFlow,
+	patch: patchTeamFlow,
+	update: updateTeamFlow,
+	delete: deleteTeamFlow,
+};

package/src/api/clients/teams/teams.ts

@@ -1,10 +1,5 @@
-import { AgentTeamServiceApiFactory } from 'webitel-sdk';
-import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+import { getAgentTeamService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
@@ -22,11 +17,6 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const teamService = AgentTeamServiceApiFactory(configuration, '', instance);
-
 const fieldsToSend = [
 	'name',
 	'description',
@@ -38,26 +28,33 @@ const fieldsToSend = [
 	'taskAcceptTimeout',
 	'callTimeout',
 	'inviteChatTimeout',
+	'screenControl',
 ];
 
 const getTeamsList = async (params: ApiParams) => {
-	const { page, size, search, sort, fields, id, strategy, adminId } =
-		applyTransform(params, [
-			merge(getDefaultGetParams()),
-			starToSearch('search'),
-		]);
+	const listFieldsToSend = [
+		'page',
+		'size',
+		'q',
+		'sort',
+		'fields',
+		'id',
+		'strategy',
+		'admin_id',
+	];
+	const requestParams = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		camelToSnake(),
+		(params) => ({
+			...params,
+			q: params.search,
+		}),
+		sanitize(listFieldsToSend),
+	]);
 
 	try {
-		const response = await teamService.searchAgentTeam(
-			page,
-			size,
-			search,
-			sort,
-			fields,
-			id,
-			strategy,
-			adminId,
-		);
+		const response = await getAgentTeamService().searchAgentTeam(requestParams);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -90,7 +87,7 @@ const getTeam = async ({ itemId: id }: GetItemParams) => {
 	};
 
 	try {
-		const response = await teamService.readAgentTeam(String(id));
+		const response = await getAgentTeamService().readAgentTeam(String(id));
 		return applyTransform(response.data, [
 			snakeToCamel(),
 			merge(defaultObject),
@@ -108,7 +105,7 @@ const addTeam = async ({ itemInstance }: AddItemParams) => {
 		camelToSnake(),
 	]);
 	try {
-		const response = await teamService.createAgentTeam(item);
+		const response = await getAgentTeamService().createAgentTeam(item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -125,7 +122,10 @@ const updateTeam = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 		camelToSnake(),
 	]);
 	try {
-		const response = await teamService.updateAgentTeam(String(id), item);
+		const response = await getAgentTeamService().updateAgentTeam(
+			String(id),
+			item,
+		);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -138,7 +138,7 @@ const updateTeam = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 
 const deleteTeam = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await teamService.deleteAgentTeam(String(id));
+		const response = await getAgentTeamService().deleteAgentTeam(String(id));
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [

package/src/api/clients/triggers/triggerJobs.ts

@@ -0,0 +1,63 @@
+import { getTriggerService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	merge,
+	notify,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type { ApiParams } from '../_shared/types';
+
+const getTriggerJobsList = async (params: ApiParams) => {
+	const {
+		parentId,
+		page,
+		size,
+		q,
+		sort,
+		fields,
+		startedAtFrom,
+		startedAtTo,
+		durationFrom,
+		durationTo,
+		result,
+	} = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await getTriggerService().searchTriggerJob(
+			Number(parentId),
+			{
+				page,
+				size,
+				q,
+				sort,
+				fields,
+				'started_at.from': startedAtFrom,
+				'started_at.to': startedAtTo,
+				'duration.from': durationFrom,
+				'duration.to': durationTo,
+				state: result,
+			},
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const TriggerJobsAPI = {
+	getList: getTriggerJobsList,
+};

package/src/api/clients/triggers/triggers.ts

@@ -0,0 +1,266 @@
+import deepCopy from 'deep-copy';
+import { getTriggerService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	AddItemParams,
+	ApiParams,
+	DeleteItemParams,
+	GetItemParams,
+	PatchItemParams,
+	UpdateItemParams,
+} from '../_shared/types';
+
+/**
+ * `variables` is a free-form string map; its keys are user data, not API
+ * fields, so the case transformers must leave them alone.
+ */
+const doNotConvertKeys = [
+	'variables',
+];
+
+const fieldsToSend = [
+	'description',
+	'enabled',
+	'id',
+	'name',
+	'schema',
+	'timeout',
+	'timezone',
+	'type',
+	'variables',
+	'expression',
+	'event',
+	'object',
+];
+
+/**
+ * The form binds `variables` as a `{ key, value }[]`, the API takes a map.
+ * `type`, `event` and `object` are bound as lookup objects; only the value
+ * goes over the wire.
+ */
+const preRequestHandler = (item: ApiParams) => {
+	const copy = deepCopy(item);
+	copy.variables = copy.variables.reduce(
+		(variables: ApiParams, variable: ApiParams) => {
+			if (!variable.key) return variables;
+			variables[variable.key] = variable.value;
+			return variables;
+		},
+		{},
+	);
+	return {
+		...copy,
+		type: copy?.type?.value ?? copy?.type,
+		event: copy?.event?.value ?? copy?.event,
+		object: copy?.object?.value ?? copy?.object,
+	};
+};
+
+const getTriggersList = async (params: ApiParams) => {
+	const listFieldsToSend = [
+		'page',
+		'size',
+		'search',
+		'sort',
+		'fields',
+		'id',
+		'schemaId',
+	];
+	const defaultObject = {
+		enabled: false,
+	};
+
+	const { page, size, search, sort, fields, id, schemaId } = applyTransform(
+		params,
+		[
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+			sanitize(listFieldsToSend),
+		],
+	);
+
+	try {
+		const response = await getTriggerService().searchTrigger({
+			page,
+			size,
+			// the generated param is `q`; `search` is what the datalist store sends
+			q: search,
+			sort,
+			fields,
+			id,
+			schema_id: schemaId,
+		});
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				mergeEach(defaultObject),
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+/**
+ * Returns `type`, `event` and `object` as raw enum values. Mapping them onto
+ * localized lookup entries is the caller's job — the labels are app-side i18n
+ * keys.
+ */
+const getTrigger = async ({ itemId: id }: GetItemParams) => {
+	const defaultObject = {
+		timeout: 0,
+		variables: {},
+	};
+
+	const responseHandler = (response: ApiParams) => {
+		const copy = deepCopy(response);
+		if (response.variables) {
+			copy.variables = Object.keys(copy.variables).map((key) => ({
+				key,
+				value: copy.variables[key],
+			}));
+		}
+		return copy;
+	};
+
+	try {
+		const response = await getTriggerService().readTrigger(Number(id));
+		return applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(defaultObject),
+			responseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addTrigger = async ({ itemInstance }: AddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await getTriggerService().createTrigger(item);
+		return applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchTrigger = async ({ changes, id }: PatchItemParams) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await getTriggerService().patchTrigger(Number(id), body);
+		return applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateTrigger = async ({
+	itemInstance,
+	itemId: id,
+}: UpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await getTriggerService().updateTrigger(Number(id), item);
+		return applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteTrigger = async ({ id }: DeleteItemParams) => {
+	try {
+		const response = await getTriggerService().deleteTrigger(Number(id));
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getTriggersLookup = (params: Parameters<typeof getTriggersList>[0]) =>
+	getTriggersList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+		],
+	});
+
+const startTrigger = async (_params: ApiParams, item: ApiParams) => {
+	const body = applyTransform(item, [
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await getTriggerService().createTriggerJob(
+			Number(item.id),
+			body,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			notify(({ callback }) =>
+				callback({
+					type: 'success',
+					text: 'Successfully ran',
+				}),
+			),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const TriggersAPI = {
+	getList: getTriggersList,
+	get: getTrigger,
+	add: addTrigger,
+	patch: patchTrigger,
+	update: updateTrigger,
+	delete: deleteTrigger,
+	getLookup: getTriggersLookup,
+	start: startTrigger,
+};

package/src/api/clients/userSettings/userSettings.ts

@@ -1,16 +1,15 @@
-import { UserSettingsApiFactory } from 'webitel-sdk';
-
-import { getDefaultInstance, getDefaultOpenAPIConfig } from '../../defaults';
+import { getDefaultAxiosInstance } from '../../axios/genClient';
 import { applyTransform, notify } from '../../transformers';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const service = UserSettingsApiFactory(configuration, '', instance);
+/*
+ * Hand-written rather than generated: `/user/settings/{key}` is absent from the
+ * OpenAPI spec orval reads, so there is no `gen-wire` service for it.
+ */
+const url = (key: string) => `/user/settings/${encodeURIComponent(key)}`;
 
 const getUserSettings = async ({ key }: { key: string }) => {
 	try {
-		const response = await service.getUserSettings(key);
+		const response = await getDefaultAxiosInstance().get(url(key));
 		return response.data;
 	} catch (err) {
 		throw applyTransform(err, [
@@ -27,7 +26,7 @@ const setUserSettings = async ({
 	value: object;
 }) => {
 	try {
-		const response = await service.setUserSettings(key, value);
+		const response = await getDefaultAxiosInstance().put(url(key), value);
 		return response.data;
 	} catch (err) {
 		throw applyTransform(err, [

package/src/api/clients/users/users.ts

@@ -42,6 +42,8 @@ const fieldsToSend = [
 	'email',
 	'contact',
 	'chatName',
+	// bound by the client's user form; `force_password_change` on ApiInputUser
+	'forcePasswordChange',
 ];
 
 const getUsersList = async (params: ApiParams) => {