@webitel/api-services 0.0.24 → 0.0.27

package/src/api/clients/slaConditions/slaConditions.ts

@@ -0,0 +1,163 @@
+import { SLAConditionsApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const slaConditionsService = SLAConditionsApiFactory(
+	configuration,
+	'',
+	instance,
+);
+
+const fieldsToSend = [
+	'name',
+	'priorities',
+	'sla_id',
+	'reaction_time',
+	'resolution_time',
+];
+
+const getConditionsList = async ({ parentId, ...rest }) => {
+	const fieldsToSend = [
+		'page',
+		'size',
+		'q',
+		'sort',
+		'fields',
+		'id',
+		'slaConditionId',
+		'priorityId',
+	];
+
+	const {
+		page,
+		size,
+		fields,
+		sort,
+		id,
+		q,
+		sla_condition_id: slaConditionId,
+		priority_id: priorityId,
+	} = applyTransform(rest, [
+		merge(getDefaultGetParams()),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await slaConditionsService.listSLAConditions(
+			parentId,
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q,
+			slaConditionId,
+			priorityId,
+		);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [snakeToCamel()]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getCondition = async ({ parentId, itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		return item.slaCondition;
+	};
+
+	try {
+		const response = await slaConditionsService.locateSLACondition(
+			parentId,
+			id,
+			fieldsToSend,
+		);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateCondition = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await slaConditionsService.updateSLACondition(
+			itemInstance.slaId,
+			id,
+			item,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addCondition = async ({ itemInstance, parentId }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await slaConditionsService.createSLACondition(
+			parentId,
+			item,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteCondition = async ({ id, parentId }) => {
+	try {
+		const response = await slaConditionsService.deleteSLACondition(
+			parentId,
+			id,
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getLookup = async (params) =>
+	getConditionsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const SLAConditionsAPI = {
+	getList: getConditionsList,
+	get: getCondition,
+	update: updateCondition,
+	delete: deleteCondition,
+	add: addCondition,
+	getLookup,
+};

package/src/api/clients/slas/slas.ts

@@ -0,0 +1,116 @@
+import { SLAsApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const slaService = SLAsApiFactory(configuration, '', instance);
+
+const fieldsToSend = [
+	'name',
+	'description',
+	'valid_from',
+	'valid_to',
+	'calendar',
+	'reaction_time',
+	'resolution_time',
+];
+
+const getSlasList = async (params) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const { page, size, fields, sort, id, q } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await slaService.listSLAs(page, size, fields, sort, id, q);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, []),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getSla = async ({ itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		return item.sla;
+	};
+
+	try {
+		const response = await slaService.locateSLA(id, fieldsToSend);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addSla = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await slaService.createSLA(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateSla = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await slaService.updateSLA(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteSla = async ({ id }) => {
+	try {
+		const response = await slaService.deleteSLA(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getSlasLookup = (params) =>
+	getSlasList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const SlasAPI = {
+	getList: getSlasList,
+	getLookup: getSlasLookup,
+	get: getSla,
+	add: addSla,
+	update: updateSla,
+	delete: deleteSla,
+};

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

@@ -0,0 +1,142 @@
+import { AgentTeamServiceApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const teamService = AgentTeamServiceApiFactory(configuration, '', instance);
+
+const fieldsToSend = [
+	'name',
+	'description',
+	'strategy',
+	'admin',
+	'maxNoAnswer',
+	'wrapUpTime',
+	'noAnswerDelayTime',
+	'taskAcceptTimeout',
+	'callTimeout',
+	'inviteChatTimeout',
+];
+
+const getTeamsList = async (params) => {
+	const { page, size, search, sort, fields, id, strategy, adminId } =
+		applyTransform(params, [
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+		]);
+
+	try {
+		const response = await teamService.searchAgentTeam(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+			strategy,
+			adminId,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getTeam = async ({ itemId: id }) => {
+	const defaultObject = {
+		name: '',
+		strategy: {},
+		admin: [],
+		description: '',
+		busyDelayTime: 0,
+		callTimeout: 0,
+		maxNoAnswer: 0,
+		noAnswerDelayTime: 0,
+		taskAcceptTimeout: 0,
+		inviteChatTimeout: 0,
+		rejectDelayTime: 0,
+		wrapUpTime: 0,
+	};
+
+	try {
+		const response = await teamService.readAgentTeam(id);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addTeam = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await teamService.createAgentTeam(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateTeam = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await teamService.updateAgentTeam(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteTeam = async ({ id }) => {
+	try {
+		const response = await teamService.deleteAgentTeam(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getTeamsLookup = (params) =>
+	getTeamsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const TeamsAPI = {
+	getList: getTeamsList,
+	get: getTeam,
+	add: addTeam,
+	update: updateTeam,
+	delete: deleteTeam,
+	getLookup: getTeamsLookup,
+};

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

@@ -0,0 +1,265 @@
+import axiosMock from '../../../../tests/mocks/axiosMock';
+
+const instanceMock = axiosMock()().default;
+
+vi.doMock('../../../defaults/getDefaultInstance/getDefaultInstance.ts', () => ({
+	default: () => instanceMock,
+}));
+
+describe('UsersAPI', () => {
+	beforeEach(() => {
+		Object.assign(instanceMock, axiosMock()().default);
+	});
+
+	it('correctly computes "getList" method api call', async () => {
+		const get = vi.fn(() =>
+			Promise.resolve({
+				data: {},
+			}),
+		);
+
+		instanceMock.get = get;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		const inputParams = {
+			fields: ['id', 'name', 'vitest'],
+		};
+		const url = '/users?fields=id&fields=name&fields=vitest&page=1&size=10';
+		await UsersAPI.getList(inputParams);
+		expect(get).toHaveBeenCalledWith(url);
+	});
+
+	it('correctly computes "getList" method output', async () => {
+		const output = {
+			items: [
+				{
+					dnd: false,
+					id: 1,
+					name: '',
+					state: true,
+					status: '',
+					shouldCaseConvert: '',
+				},
+			],
+			next: true,
+		};
+
+		const response = {
+			data: {
+				items: [{ id: 1, should_case_convert: '' }],
+				next: true,
+			},
+		};
+
+		const get = vi.fn(() => Promise.resolve(response));
+
+		instanceMock.get = get;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		expect(await UsersAPI.getList({})).toEqual(output);
+	});
+
+	it('correctly computes "get" method api call', async () => {
+		const inputParams = {
+			itemId: 1,
+		};
+		const url = '/users/1';
+
+		const get = vi.fn(() =>
+			Promise.resolve({
+				data: {},
+			}),
+		);
+
+		instanceMock.get = get;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		await UsersAPI.get(inputParams);
+		expect(get).toHaveBeenCalledWith(url);
+	});
+
+	it('correctly computes "get" method output', async () => {
+		const output = {
+			id: 1,
+			device: {},
+			devices: [],
+			license: [],
+			roles: [],
+			variables: [
+				{
+					key: '',
+					value: '',
+				},
+			],
+		};
+
+		const response = {
+			data: {
+				id: 1,
+			},
+		};
+
+		const get = vi.fn(() => Promise.resolve(response));
+
+		instanceMock.get = get;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		expect(await UsersAPI.get({})).toEqual(output);
+	});
+
+	it('correctly computes "add" method api call', async () => {
+		const input = {
+			itemInstance: {
+				name: 'test',
+			},
+		};
+
+		const body = {
+			name: 'test',
+			profile: {}, // variables field (?)
+		};
+
+		const url = '/users';
+
+		const post = vi.fn(() =>
+			Promise.resolve({
+				data: {},
+			}),
+		);
+
+		instanceMock.post = post;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		await UsersAPI.add(input);
+		expect(post).toHaveBeenCalledWith(url, body);
+	});
+
+	it('correctly computes "add" method output', async () => {
+		const output = {
+			id: 1,
+			checkCase: '',
+		};
+
+		const response = {
+			data: {
+				id: 1,
+				check_case: '',
+			},
+		};
+
+		const post = vi.fn(() => Promise.resolve(response));
+
+		instanceMock.post = post;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		expect(await UsersAPI.add({ itemInstance: {} })).toEqual(output);
+	});
+
+	it('correctly computes "update" method api call', async () => {
+		const input = {
+			itemInstance: {
+				name: 'test',
+			},
+			itemId: 1,
+		};
+
+		const body = {
+			name: 'test',
+			profile: {}, // variables field (?)
+		};
+
+		const url = '/users/1';
+
+		const put = vi.fn(() =>
+			Promise.resolve({
+				data: {},
+			}),
+		);
+
+		instanceMock.put = put;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		await UsersAPI.update(input);
+		expect(put).toHaveBeenCalledWith(url, body);
+	});
+
+	it('correctly computes "update" method output', async () => {
+		const output = {
+			id: 1,
+			checkCase: '',
+		};
+
+		const response = {
+			data: {
+				id: 1,
+				check_case: '',
+			},
+		};
+
+		const put = vi.fn(() => Promise.resolve(response));
+
+		instanceMock.put = put;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		expect(await UsersAPI.update({ itemInstance: {}, itemId: 1 })).toEqual(
+			output,
+		);
+	});
+
+	it('correctly computes "patch" method api call', async () => {
+		const input = {
+			changes: {
+				name: 'test',
+			},
+			id: 1,
+		};
+
+		const body = {
+			name: 'test',
+		};
+
+		const url = '/users/1';
+
+		const patch = vi.fn(() =>
+			Promise.resolve({
+				data: {},
+			}),
+		);
+
+		instanceMock.patch = patch;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		await UsersAPI.patch(input);
+		expect(patch).toHaveBeenCalledWith(url, body);
+	});
+
+	it('correctly computes "delete" method api call', async () => {
+		const input = {
+			id: 1,
+		};
+
+		const url = '/users/1?permanent=true';
+
+		const _delete = vi.fn(() =>
+			Promise.resolve({
+				data: {},
+			}),
+		);
+
+		instanceMock.delete = _delete;
+
+		const UsersAPI = (await import('../users.ts')).default;
+
+		await UsersAPI.delete(input);
+		expect(_delete).toHaveBeenCalledWith(url);
+	});
+});