@webitel/api-services 0.0.24 → 0.0.27

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

@@ -0,0 +1,232 @@
+import deepCopy from 'deep-copy';
+import { QueueServiceApiFactory } from 'webitel-sdk';
+
+import isEmpty from '../../../scripts/isEmpty';
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+import processing from './defaults/processing';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const queueService = QueueServiceApiFactory(configuration, '', instance);
+
+const doNotConvertKeys = ['variables'];
+
+const fieldsToSend = [
+	'name',
+	'type',
+	'strategy',
+	'team',
+	'priority',
+	'dncList',
+	'schema',
+	'payload',
+	'taskProcessing',
+	'maxOfRetry',
+	'timeout',
+	'secBetweenRetries',
+	'variables',
+	'calendar',
+	'description',
+	'enabled',
+	'ringtone',
+	'doSchema',
+	'afterSchema',
+	'stickyAgent',
+	'grantee',
+	'tags',
+];
+
+const preRequestHandler = (item) => {
+	const copy = deepCopy(item);
+	copy.variables = copy.variables.reduce((variables, variable) => {
+		if (!variable.key) return variables;
+		return { ...variables, [variable.key]: variable.value };
+	}, {});
+	return copy;
+};
+
+const getQueuesList = async (params) => {
+	const defaultObject = {
+		type: 0,
+		enabled: false,
+		active: 0,
+		waiting: 0,
+		priority: '0',
+	};
+
+	const { page, size, search, sort, fields, id, queueType, team, tags } =
+		applyTransform(params, [
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+		]);
+
+	try {
+		const response = await queueService.searchQueue(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+			queueType,
+			team,
+			tags,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [mergeEach(defaultObject)]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getQueue = async ({ itemId: id }) => {
+	const defaultObject = {
+		tags: [],
+		type: 0,
+		formSchema: {},
+		taskProcessing: {},
+	};
+	const responseHandler = (item) => {
+		const copy = deepCopy(item);
+		if (copy.variables) {
+			copy.variables = Object.keys(copy.variables).map((key) => ({
+				key,
+				value: copy.variables[key],
+			}));
+		}
+		if (isEmpty(copy.taskProcessing)) {
+			copy.taskProcessing = processing({
+				enabled: !!copy.processing,
+				formSchema: copy.formSchema,
+				sec: copy.processingSec || 0,
+				renewalSec: copy.processingRenewalSec || 0,
+			});
+		}
+		return copy;
+	};
+	try {
+		const response = await queueService.readQueue(id);
+		return applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(defaultObject),
+			responseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addQueue = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await queueService.createQueue(item);
+		return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateQueue = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await queueService.updateQueue(id, item);
+		return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchQueue = async ({ id, changes }) => {
+	const item = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await queueService.patchQueue(id, item);
+		return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteQueue = async ({ id }) => {
+	try {
+		const response = await queueService.deleteQueue(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getQueuesLookup = (params) =>
+	getQueuesList({
+		...params,
+		fields: params.fields || ['id', 'name', 'type'],
+	});
+
+const getQueuesTags = async (params) => {
+	const { page, size, search, sort, fields } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch(),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await queueService.searchQueueTags(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const QueuesAPI = {
+	getList: getQueuesList,
+	get: getQueue,
+	add: addQueue,
+	patch: patchQueue,
+	update: updateQueue,
+	delete: deleteQueue,
+	getLookup: getQueuesLookup,
+	getQueuesTags,
+};

package/src/api/clients/quickReplies/quickReplies.ts

@@ -0,0 +1,108 @@
+import { getQuickRepliesService } from '@webitel/api-services/gen';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers/index';
+
+const quickReplyService = getQuickRepliesService();
+
+const fieldsToSend = ['name', 'queues', 'article', 'teams', 'text'];
+
+const getQuickRepliesList = 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 quickReplyService.searchQuickReplies({
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q,
+		});
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [snakeToCamel()]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getQuickReply = async ({ itemId: id }) => {
+	try {
+		const response = await quickReplyService.readQuickReply(id);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addQuickReply = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await quickReplyService.createQuickReply(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateQuickReply = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await quickReplyService.updateQuickReply(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteQuickReply = async ({ id }) => {
+	try {
+		const response = await quickReplyService.deleteQuickReply(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getLookup = (params) =>
+	getQuickRepliesList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const QuickRepliesAPI = {
+	getList: getQuickRepliesList,
+	get: getQuickReply,
+	add: addQuickReply,
+	update: updateQuickReply,
+	delete: deleteQuickReply,
+	getLookup,
+};

package/src/api/clients/roles/roles.ts

@@ -0,0 +1,200 @@
+import deepCopy from 'deep-copy';
+
+import ApplicationsAccess from '../../../modules/Userinfo/classes/ApplicationsAccess';
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	generateUrl,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/roles';
+const fieldsToSend = ['name', 'description', 'permissions', 'metadata'];
+
+const preRequestHandler = (item) => {
+	const copy = deepCopy(item);
+	copy.metadata.access = ApplicationsAccess.minify(copy.metadata.access);
+	return copy;
+};
+
+const getRoleList = async (params) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'ids'];
+
+	const url = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		(params) => {
+			params.ids = params.ids || params.id; // accept either ids or id as param
+			return params;
+		},
+		starToSearch('search'),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+		generateUrl(baseUrl),
+	]);
+	try {
+		const response = await instance.get(url);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getRole = async ({ itemId: id }) => {
+	const defaultObject = {
+		name: '',
+		description: '',
+		permissions: [],
+		metadata: {},
+	};
+
+	const itemResponseHandler = (response) => {
+		const copy = deepCopy(response);
+		copy.metadata.access = new ApplicationsAccess({
+			access: copy.metadata.access,
+		}).getAccess();
+		return copy;
+	};
+
+	const url = `${baseUrl}/${id}?fields=metadata&fields=permissions&fields=name&fields=description`;
+
+	try {
+		const response = await instance.get(url);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getExtendedRoles = async (params) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const url = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+		generateUrl(baseUrl),
+	]);
+	try {
+		const response = await instance.get(url);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addRole = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await instance.post(baseUrl, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateRole = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+
+	const url = `${baseUrl}/${id}`;
+	try {
+		const response = await instance.put(url, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteRole = async ({ id }) => {
+	const url = `${baseUrl}/${id}`;
+	try {
+		const response = await instance.delete(url);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getRolesLookup = (params) =>
+	getRoleList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+const PERMISSIONS_LIST_URL = '/permissions';
+
+const getPermissionsOptions = async (params) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const url = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+		generateUrl(PERMISSIONS_LIST_URL),
+	]);
+	try {
+		const response = await instance.get(url);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const RolesAPI = {
+	getList: getRoleList,
+	get: getRole,
+	add: addRole,
+	update: updateRole,
+	delete: deleteRole,
+	getLookup: getRolesLookup,
+
+	getExtendedRoles,
+	getPermissionsOptions,
+};

package/src/api/clients/skills/skills.ts

@@ -0,0 +1,110 @@
+import { SkillServiceApiFactory } 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 skillService = SkillServiceApiFactory(configuration, '', instance);
+
+const getSkillsList = async (params) => {
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await skillService.searchSkill(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getSkill = async ({ itemId: id }) => {
+	try {
+		const response = await skillService.readSkill(id);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = ['name', 'description'];
+
+const addSkill = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await skillService.createSkill(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateSkill = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await skillService.updateSkill(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteSkill = async ({ id }) => {
+	try {
+		const response = await skillService.deleteSkill(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getSkillsLookup = (params) =>
+	getSkillsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const SkillsAPI = {
+	getList: getSkillsList,
+	get: getSkill,
+	add: addSkill,
+	update: updateSkill,
+	delete: deleteSkill,
+	getLookup: getSkillsLookup,
+};