@webitel/api-services 0.0.24 → 0.0.27

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

@@ -0,0 +1,173 @@
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	generateUrl,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+import registerGateway from './defaults/registerGateway';
+import trunkingGateway from './defaults/trunkingGateway';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/sip/gateways';
+
+const getGatewayList = async (params) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id', 'name'];
+
+	const defaultObject = {
+		name: '',
+		proxy: '',
+		enable: false,
+	};
+
+	const url = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		starToSearch('name'),
+		(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: applyTransform(items, [mergeEach(defaultObject)]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getGateway = async ({ itemId: id }) => {
+	const coerceTrunkingResponse = (response) => {
+		const defaultIPacl = {
+			ip: '',
+			proto: 'any',
+			port: null,
+		};
+
+		const result = { ...trunkingGateway(), ...response };
+		result.ipacl = result.ipacl.map((acl) => ({ ...defaultIPacl, ...acl }));
+		return result;
+	};
+
+	const coerceRegisterResponse = (response) => {
+		const result = { ...registerGateway(), ...response };
+		return result;
+	};
+
+	const itemResponseHandler = (response) => {
+		if (response.register) return coerceRegisterResponse(response);
+		return coerceTrunkingResponse(response);
+	};
+
+	const url = `${baseUrl}/${id}`;
+
+	try {
+		const response = await instance.get(url);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = [
+	'name',
+	'proxy',
+	'id',
+	'host',
+	'ipacl',
+	'account',
+	'username',
+	'expires',
+	'account',
+	'registrar',
+	'name',
+	'register',
+	'password',
+	'schema',
+	'usage',
+	'enable',
+];
+
+const addGateway = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await instance.post(baseUrl, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+const updateGateway = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		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 patchGateway = async ({ changes, id }) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	const url = `${baseUrl}/${id}`;
+	try {
+		const response = await instance.patch(url, body);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteGateway = async ({ id }) => {
+	const url = `${baseUrl}/${id}`;
+	try {
+		const response = await instance.delete(url);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getGatewaysLookup = (params) =>
+	getGatewayList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const GatewaysAPI = {
+	getList: getGatewayList,
+	get: getGateway,
+	add: addGateway,
+	patch: patchGateway,
+	update: updateGateway,
+	delete: deleteGateway,
+	getLookup: getGatewaysLookup,
+};

package/src/api/clients/index.ts

@@ -0,0 +1,68 @@
+import agentChats from './agents/agentChats';
+import agents from './agents/agents';
+import buckets from './buckets/buckets';
+import calendars from './calendars/calendars';
+import caseCloseReasonGroups from './caseCloseReasonGroups/caseCloseReasonGroups';
+import caseCloseReasons from './caseCloseReasons/caseCloseReasons';
+import casePriorities from './casePriorities/casePriorities';
+import caseServiceCatalogs from './caseServiceCatalogs/serviceCatalogs';
+import caseSources from './caseSources/caseSources';
+import caseStatusConditions from './caseStatusConditions/caseStatusConditions';
+import caseStatuses from './caseStatuses/caseStatuses';
+import catalog from './catalog/catalog';
+import chatGateways from './chatGateways/chatGateways';
+import communications from './communications/communications';
+import configurations from './configurations/configurations';
+import contactGroups from './contactGroups/contactGroups';
+import flows from './flows/flow';
+import gateways from './gateways/gateways';
+import labels from './labels/labels';
+import lists from './lists/blacklists';
+import media from './media/media';
+import object from './object/object';
+import queues from './queues/queues';
+import quickReplies from './quickReplies/quickReplies';
+import roles from './roles/roles';
+import skills from './skills/skills';
+import slas from './slas/slas';
+import teams from './teams/teams';
+import users from './users/users';
+import sysTypes from './wtTypes/sysTypes/sysTypes';
+import typeExtensions from './wtTypes/typeExtensions/typeExtensions';
+import { contactChatMessagesHistory, contacts } from './сontacts/index';
+
+export {
+	agentChats,
+	agents,
+	buckets,
+	calendars,
+	caseCloseReasonGroups,
+	caseCloseReasons,
+	casePriorities,
+	caseServiceCatalogs,
+	caseSources,
+	caseStatusConditions,
+	caseStatuses,
+	catalog,
+	chatGateways,
+	communications,
+	configurations,
+	contactChatMessagesHistory,
+	contactGroups,
+	contacts,
+	flows,
+	gateways,
+	labels,
+	lists,
+	media,
+	object,
+	queues,
+	quickReplies,
+	roles,
+	skills,
+	slas,
+	sysTypes,
+	teams,
+	typeExtensions,
+	users,
+};

package/src/api/clients/labels/labels.ts

@@ -0,0 +1,53 @@
+import { LabelsApiFactory } from 'webitel-sdk';
+import {
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const service = LabelsApiFactory(configuration, '', instance);
+
+const getList = async (params) => {
+	const fieldsToSend = ['page', 'size', 'search', 'sort', 'fields', 'id'];
+	const { page, size, search } = applyTransform(params, [
+		sanitize(fieldsToSend),
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		camelToSnake(),
+	]);
+	try {
+		const response = await service.getLabels(page, size, search);
+		const { labels, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge({ labels: [], next: false }),
+		]);
+		return {
+			items: labels,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getLabelsLookup = (params) =>
+	getList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const LabelsAPI = {
+	getList,
+	getLookup: getLabelsLookup,
+};

package/src/api/clients/lists/blacklists.ts

@@ -0,0 +1,116 @@
+import { ListServiceApiFactory } 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 listService = ListServiceApiFactory(configuration, '', instance);
+
+const getBlacklistList = async (params) => {
+	const defaultObject = {
+		name: '',
+		count: 0,
+	};
+
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		camelToSnake(),
+	]);
+
+	try {
+		const response = await listService.searchList(
+			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 getBlacklist = async ({ itemId: id }) => {
+	try {
+		const response = await listService.readList(id);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = ['name', 'description'];
+
+const addBlacklist = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await listService.createList(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateBlacklist = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await listService.updateList(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteBlacklist = async ({ id }) => {
+	try {
+		const response = await listService.deleteList(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+const getBlacklistsLookup = (params) =>
+	getBlacklistList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const BlacklistsAPI = {
+	getList: getBlacklistList,
+	get: getBlacklist,
+	add: addBlacklist,
+	update: updateBlacklist,
+	delete: deleteBlacklist,
+	getLookup: getBlacklistsLookup,
+};

package/src/api/clients/media/media.ts

@@ -0,0 +1,114 @@
+import axios from 'axios';
+import { MediaFileServiceApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	merge,
+	notify,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const mediaService = MediaFileServiceApiFactory(configuration, '', instance);
+
+const token = localStorage.getItem('access-token');
+const baseUrl = import.meta.env.VITE_API_URL;
+
+const getMediaList = async (params) => {
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await mediaService.searchMediaFile(
+			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 getMedia = async ({ itemId }) => {
+	const url = `${baseUrl}/storage/media/${itemId}/stream?access_token=${token}`;
+	try {
+		return await instance.get(url);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const downloadMedia = async (id) => {
+	const url = `${baseUrl}/storage/media/${id}/download?access_token=${token}`;
+	try {
+		return await instance.get(url);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addMediaInstance = axios.create({
+	headers: {
+		'content-type': 'multipart/form-data',
+	},
+});
+
+const addMedia = async (params) => {
+	const url = `${baseUrl}/storage/media?access_token=${token}`;
+
+	const formData = new FormData();
+	formData.append('file', params.itemInstance);
+	try {
+		const response = await addMediaInstance.post(url, formData);
+		applyTransform(response, [
+			notify(() => ({ type: 'success', text: 'Successfully added' })),
+		]);
+		return response;
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteMedia = async ({ id }) => {
+	try {
+		const response = await mediaService.deleteMediaFile(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getMediaLookup = (params) =>
+	getMediaList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const MediaAPI = {
+	getList: getMediaList,
+	get: getMedia,
+	add: addMedia,
+	delete: deleteMedia,
+	getLookup: getMediaLookup,
+};

package/src/api/clients/object/object.ts

@@ -0,0 +1,112 @@
+import { TypesApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	generateUrl,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const typeService = TypesApiFactory(configuration, '', instance);
+
+const getObjectList = async (params) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const { page, size, fields, sort, id, q } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await typeService.search(
+			q,
+			id,
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			size,
+			page,
+			sort,
+			fields,
+		);
+		const { data, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+
+		const itemResponseHandler = (items) =>
+			(items || []).map((item) => ({
+				...item,
+				id: item.repo,
+			}));
+
+		return {
+			items: applyTransform(data, [snakeToCamel(), itemResponseHandler]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getObjectLookupList = async ({ ...params }) => {
+	const fieldsToSend = [
+		'page',
+		'size',
+		'q',
+		'sort',
+		'extensions',
+		'fields',
+		'id',
+	];
+
+	const url = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		(params) => ({ ...params, q: params.search, extensions: false }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+		generateUrl('types'),
+	]);
+	try {
+		const response = await instance.get(url);
+		const { data, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+
+		return {
+			items: data ?? [],
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getObjectLookup = async (params) =>
+	getObjectLookupList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const ObjectsAPI = {
+	getList: getObjectList,
+	getLookup: getObjectLookup,
+};

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

@@ -0,0 +1,14 @@
+import deepmerge from 'deepmerge';
+
+const processing = (processing = {}) =>
+	deepmerge(
+		{
+			enabled: false,
+			formSchema: {},
+			sec: 30,
+			renewalSec: 15,
+		},
+		processing,
+	);
+
+export default processing;