@webitel/api-services 0.0.24 → 0.0.27

package/src/api/clients/communications/communications.ts

@@ -0,0 +1,139 @@
+import { CommunicationTypeServiceApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const communicationService = CommunicationTypeServiceApiFactory(
+	configuration,
+	'',
+	instance,
+);
+
+const getCommunicationsList = async (params) => {
+	const defaultObject = {
+		default: false,
+	};
+
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await communicationService.searchCommunicationType(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [mergeEach(defaultObject)]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getCommunication = async ({ itemId: id }) => {
+	try {
+		const response = await communicationService.readCommunicationType(id);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = ['code', 'name', 'description', 'channel', 'default'];
+
+const addCommunication = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await communicationService.createCommunicationType(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchCommunication = async ({ changes, id }) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await communicationService.patchCommunicationType(
+			id,
+			body,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateCommunication = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await communicationService.updateCommunicationType(
+			id,
+			item,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteCommunication = async ({ id }) => {
+	try {
+		const response = await communicationService.deleteCommunicationType(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getCommunicationsLookup = (params) =>
+	getCommunicationsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const CommunicationsAPI = {
+	getList: getCommunicationsList,
+	get: getCommunication,
+	add: addCommunication,
+	patch: patchCommunication,
+	update: updateCommunication,
+	delete: deleteCommunication,
+	getLookup: getCommunicationsLookup,
+};

package/src/api/clients/configurations/configurations.ts

@@ -0,0 +1,142 @@
+import { SystemSettingServiceApiFactory } 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 configurationService = SystemSettingServiceApiFactory(
+	configuration,
+	'',
+	instance,
+);
+
+const getList = async (params) => {
+	const { page, size, search, sort, fields, name } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await configurationService.searchSystemSetting(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			name,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const get = async ({ itemId: id }) => {
+	try {
+		const response = await configurationService.readSystemSetting(id);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = ['id', 'name', 'value'];
+
+const add = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await configurationService.createSystemSetting(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const update = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await configurationService.updateSystemSetting(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getLookup = (params) =>
+	getList({
+		...params,
+		fields: params.fields || ['name'],
+	});
+
+const deleteItem = async ({ id }) => {
+	try {
+		const response = await configurationService.deleteSystemSetting(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getObjectsList = async (params) => {
+	const { page, size, search, sort, fields } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await configurationService.searchAvailableSystemSetting(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const ConfigurationsAPI = {
+	getList,
+	get,
+	add,
+	update,
+	delete: deleteItem,
+	getLookup,
+	getObjectsList,
+};

package/src/api/clients/contactGroups/contactGroups.ts

@@ -0,0 +1,184 @@
+import { GroupsApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers/index';
+import { generatePermissionsApi } from '../_shared/generatePermissionsApi';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const contactGroupsService = GroupsApiFactory(configuration, '', instance);
+
+const baseUrl = '/contacts/groups';
+
+const fieldsToSend = [
+	'name',
+	'description',
+	'enabled',
+	'type',
+	'default_group',
+];
+
+const getContactGroupsList = async (params) => {
+	const fieldsToSend = [
+		'page',
+		'size',
+		'q',
+		'sort',
+		'fields',
+		'type',
+		'enabled',
+		'id',
+	];
+	const defaultObject = {
+		enabled: false,
+	};
+
+	const { page, size, fields, sort, id, q, name, type, enabled } =
+		applyTransform(params, [
+			merge(getDefaultGetParams()),
+			(params) => ({ ...params, q: params.search }),
+			sanitize(fieldsToSend),
+			camelToSnake(),
+		]);
+
+	try {
+		const response = await contactGroupsService.listGroups(
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q,
+			name,
+			type,
+			enabled,
+		);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [mergeEach(defaultObject)]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getContactGroup = async ({ itemId: id }) => {
+	const itemResponseHandler = (item) => item.group;
+
+	try {
+		const response = await contactGroupsService.locateGroup(id, fieldsToSend);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addStaticContactGroup = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await contactGroupsService.createGroup(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addContactsToGroups = async ({ contactIds, groupIds }) => {
+	try {
+		const response = await contactGroupsService.addContactsToGroups({
+			groupIds,
+			contactIds,
+		});
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const removeContactsFromGroup = async ({ id, contactIds }) => {
+	try {
+		const response = await contactGroupsService.removeContactsFromGroup(
+			id,
+			contactIds,
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateStaticContactGroup = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await contactGroupsService.updateGroup(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchStaticContactGroup = async ({ id, changes }) => {
+	const item = applyTransform(changes, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await contactGroupsService.updateGroup2(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteStaticContactGroup = async ({ id }) => {
+	try {
+		const response = await contactGroupsService.deleteGroup(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getLookup = (params) =>
+	getContactGroupsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const ContactGroupsAPI = {
+	getList: getContactGroupsList,
+	get: getContactGroup,
+	add: addStaticContactGroup,
+	update: updateStaticContactGroup,
+	patch: patchStaticContactGroup,
+	delete: deleteStaticContactGroup,
+	getLookup,
+	addContactsToGroups,
+	removeContactsFromGroup,
+
+	...generatePermissionsApi(baseUrl),
+};

package/src/api/clients/flows/flow.ts

@@ -0,0 +1,219 @@
+import {
+	EngineRoutingSchemaType,
+	RoutingSchemaServiceApiFactory,
+} from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const flowService = RoutingSchemaServiceApiFactory(configuration, '', instance);
+
+/*
+CONVERT "SCHEMA" FIELD TO JSON TO PREVENT ITS CHANGE
+BY CAMEL-SNAKE TRANSFORMERS
+ */
+const doNotConvertKeys = ['schema'];
+
+const fieldsToSend = ['name', 'schema', 'type', 'payload', 'editor', 'tags'];
+
+const getFlowList = async (params) => {
+	const defaultObject = {
+		type: EngineRoutingSchemaType.Default,
+		editor: false,
+	};
+
+	const paramsCopy = {
+		...params,
+	};
+
+	if (paramsCopy.type) {
+		const _type = Array.isArray(paramsCopy.type)
+			? paramsCopy.type
+			: [paramsCopy.type];
+		if (!paramsCopy.type.includes(EngineRoutingSchemaType.Default)) {
+			_type.push(EngineRoutingSchemaType.Default);
+		}
+		paramsCopy.type = _type;
+	}
+
+	const { page, size, search, sort, fields, id, name, type, tags } =
+		applyTransform(paramsCopy, [
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+			camelToSnake(doNotConvertKeys),
+		]);
+
+	try {
+		const response = await flowService.searchRoutingSchema(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+			name,
+			type,
+			undefined,
+			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 getFlow = async ({ itemId: id }) => {
+	const defaultObject = {
+		tags: [],
+		editor: false,
+		type: EngineRoutingSchemaType.Default,
+	};
+
+	const itemResponseHandler = (item) => ({
+		...item,
+		schema: JSON.stringify(item.schema, null, 4),
+	});
+
+	try {
+		const response = await flowService.readRoutingSchema(id);
+		return applyTransform(response.data, [
+			({ payload, schema, ...rest }) => ({
+				payload,
+				schema,
+				...snakeToCamel(doNotConvertKeys)(rest),
+			}),
+			merge(defaultObject),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const preRequestHandler = (item) => ({
+	...item,
+	schema:
+		typeof item.schema === 'string' ? JSON.parse(item.schema) : item.schema,
+});
+
+const addFlow = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		({ payload, schema, ...rest }) => ({
+			payload,
+			schema,
+			...camelToSnake(doNotConvertKeys)(rest),
+		}),
+	]);
+	try {
+		const response = await flowService.createRoutingSchema(item);
+		return applyTransform(response.data, [
+			({ payload, schema, ...rest }) => ({
+				payload,
+				schema,
+				...snakeToCamel(doNotConvertKeys)(rest),
+			}),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+const updateFlow = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		({ payload, schema, ...rest }) => ({
+			payload,
+			schema,
+			...camelToSnake(doNotConvertKeys)(rest),
+		}),
+	]);
+	try {
+		const response = await flowService.updateRoutingSchema(id, item);
+		return applyTransform(response.data, [
+			({ payload, schema, ...rest }) => ({
+				payload,
+				schema,
+				...snakeToCamel(doNotConvertKeys)(rest),
+			}),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteFlow = async ({ id }) => {
+	try {
+		const response = await flowService.deleteRoutingSchema(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getFlowsLookup = (params) =>
+	getFlowList({
+		...params,
+		fields: params.fields || ['id', 'name', 'type'],
+	});
+
+const getFlowTags = async (params) => {
+	const { page, size, search, sort, fields, ids } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch(),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await flowService.searchRoutingSchemaTags(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			ids,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const FlowsAPI = {
+	getList: getFlowList,
+	get: getFlow,
+	add: addFlow,
+	update: updateFlow,
+	delete: deleteFlow,
+	getLookup: getFlowsLookup,
+	getFlowTags,
+};

package/src/api/clients/gateways/defaults/defaultGateway.ts

@@ -0,0 +1,9 @@
+const defaultGateway = () => ({
+	name: '',
+	usage: '',
+	proxy: '',
+	schema: {},
+	enable: true,
+});
+
+export default defaultGateway;

package/src/api/clients/gateways/defaults/registerGateway.ts

@@ -0,0 +1,12 @@
+import defaultGateway from './defaultGateway';
+
+const registerGateway = () => ({
+	...defaultGateway(),
+	register: true,
+	account: '',
+	username: '',
+	expires: 600,
+	password: '',
+});
+
+export default registerGateway;

package/src/api/clients/gateways/defaults/trunkingGateway.ts

@@ -0,0 +1,16 @@
+import defaultGateway from './defaultGateway';
+
+const trunkingGateway = () => ({
+	...defaultGateway(),
+	register: false,
+	host: '',
+	ipacl: [
+		// {
+		//   ip: '',
+		//   proto: 'any',
+		//   port: null,
+		// },
+	],
+});
+
+export default trunkingGateway;