@webitel/api-services 0.0.24 → 0.0.27

package/src/api/clients/caseStatuses/caseStatuses.ts

@@ -0,0 +1,117 @@
+import { StatusesApiFactory } 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 statusesService = StatusesApiFactory(configuration, '', instance);
+
+const fieldsToSend = ['name', 'description'];
+
+const getStatusesList = 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 statusesService.listStatuses(
+			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 getStatus = async ({ itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		return item.status;
+	};
+
+	try {
+		const response = await statusesService.locateStatus(id, fieldsToSend);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addStatus = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await statusesService.createStatus(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateStatus = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await statusesService.updateStatus(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteStatus = async ({ id }) => {
+	try {
+		const response = await statusesService.deleteStatus(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getStatusesLookup = async (params) =>
+	getStatusesList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const CaseStatusesAPI = {
+	getList: getStatusesList,
+	get: getStatus,
+	update: updateStatus,
+	getLookup: getStatusesLookup,
+	delete: deleteStatus,
+	add: addStatus,
+};

package/src/api/clients/catalog/catalog.ts

@@ -0,0 +1,39 @@
+import { CatalogApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, { notify, snakeToCamel } from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const catalogService = CatalogApiFactory(configuration, '', instance);
+
+const getChatMessagesList = async ({ chatId }) => {
+	const mergeMessagesData = ({ messages, peers }) => {
+		if (!messages) return [];
+		return messages.map(({ from, ...message }) => {
+			return {
+				...message,
+				peer: peers[from.id - 1],
+			};
+		});
+	};
+
+	try {
+		const response = await catalogService.getHistory(chatId);
+		const { messages, peers } = applyTransform(response.data, [snakeToCamel()]);
+		return {
+			items: applyTransform({ messages, peers }, [mergeMessagesData]),
+			peers,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const CatalogAPI = {
+	getChatMessagesList,
+};

package/src/api/clients/chatGateways/chatGateways.ts

@@ -0,0 +1,303 @@
+import deepCopy from 'deep-copy';
+import deepmerge from 'deepmerge';
+
+import ChatGatewayProvider from '../../../enums/ChatGatewayProvider/ChatGatewayProvider.enum';
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+} from '../../defaults/index';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+import { webChatGateway } from './defaults/webChatGateway';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/chat/bots';
+const fieldsToSend = [
+	'name',
+	'uri',
+	'flow',
+	'enabled',
+	'provider',
+	'metadata',
+	'updates',
+];
+
+const convertWebchatSeconds = (num) => `${num}s`;
+
+const parseTimeoutSeconds = (item) =>
+	item.includes('s') ? Number.parseInt(item.replace('/s', '/'), 10) : +item;
+
+const webchatRequestConverter = (data) => {
+	const copy = deepCopy(data);
+	if (data.metadata.readTimeout) {
+		copy.metadata.readTimeout = convertWebchatSeconds(
+			data.metadata.readTimeout,
+		);
+	}
+	if (data.metadata.writeTimeout) {
+		copy.metadata.writeTimeout = convertWebchatSeconds(
+			data.metadata.writeTimeout,
+		);
+	}
+	if (data.metadata.handshakeTimeout) {
+		copy.metadata.handshakeTimeout = convertWebchatSeconds(
+			data.metadata.handshakeTimeout,
+		);
+	}
+	if (data.metadata.allowOrigin) {
+		copy.metadata.allowOrigin = data.metadata.allowOrigin.join();
+	}
+
+	copy.metadata.view = JSON.stringify(data.metadata.view);
+	copy.metadata.chat = JSON.stringify(data.metadata.chat);
+	copy.metadata.appointment = JSON.stringify(data.metadata.appointment);
+	copy.metadata.alternativeChannels = JSON.stringify(
+		data.metadata.alternativeChannels,
+	);
+	copy.metadata.call = JSON.stringify(data.metadata.call);
+
+	if (copy.metadata.captcha.enabled) {
+		copy.metadata.captcha = JSON.stringify(data.metadata.captcha);
+	} else {
+		copy.metadata.captcha = undefined;
+	}
+	copy.metadata._btnCodeDirty = data.metadata._btnCodeDirty.toString();
+	return copy;
+};
+
+const messengerRequestConverter = (data) => {
+	const copy = deepCopy(data);
+	copy.metadata.instagramComments = data.metadata.instagramComments.toString();
+	copy.metadata.instagramMentions = data.metadata.instagramMentions.toString();
+	return copy;
+};
+
+const viberRequestConverter = (item) => {
+	const copy = deepCopy(item);
+	copy.metadata['btn.back.color'] = item.metadata.btnBackColor;
+	copy.metadata.btnBackColor = undefined;
+	copy.metadata['btn.font.color'] = item.metadata.btnFontColor;
+	copy.metadata.btnFontColor = undefined;
+	return copy;
+};
+
+const webChatResponseConverter = (data) => {
+	const copy = deepCopy(data);
+	copy.metadata.allowOrigin = data.metadata.allowOrigin
+		? data.metadata.allowOrigin.split(',')
+		: [];
+	if (data.metadata.readTimeout) {
+		copy.metadata.readTimeout = parseTimeoutSeconds(data.metadata.readTimeout);
+	}
+	if (data.metadata.writeTimeout) {
+		copy.metadata.writeTimeout = parseTimeoutSeconds(
+			data.metadata.writeTimeout,
+		);
+	}
+	if (data.metadata.handshakeTimeout) {
+		copy.metadata.handshakeTimeout = parseTimeoutSeconds(
+			data.metadata.handshakeTimeout,
+		);
+	}
+	if (data.metadata.view) {
+		copy.metadata.view = JSON.parse(data.metadata.view);
+	}
+	if (data.metadata.chat) {
+		copy.metadata.chat = JSON.parse(data.metadata.chat);
+	}
+	if (data.metadata.appointment) {
+		copy.metadata.appointment = JSON.parse(data.metadata.appointment);
+	}
+	if (data.metadata.alternativeChannels) {
+		copy.metadata.alternativeChannels = JSON.parse(
+			data.metadata.alternativeChannels,
+		);
+	}
+	if (data.metadata.call) {
+		copy.metadata.call = JSON.parse(data.metadata.call);
+	}
+	if (data.metadata.captcha) {
+		copy.metadata.captcha = JSON.parse(data.metadata.captcha);
+	}
+	copy.metadata._btnCodeDirty = data.metadata._btnCodeDirty === 'true';
+
+	return deepmerge(webChatGateway(), copy);
+};
+
+const messengerResponseConverter = (item) => {
+	const copy = deepCopy(item);
+	copy.metadata.instagramComments = item.metadata.instagramComments === 'true';
+	copy.metadata.instagramMentions = item.metadata.instagramMentions === 'true';
+	return copy;
+};
+
+const viberResponseConverter = (item) => {
+	const copy = deepCopy(item);
+	if (item.metadata['btn.back.color'])
+		copy.metadata.btnBackColor = item.metadata['btn.back.color'];
+	if (item.metadata['btn.font.color'])
+		copy.metadata.btnFontColor = item.metadata['btn.font.color'];
+	return copy;
+};
+
+const preRequestHandler = (item) => {
+	switch (item.provider) {
+		case ChatGatewayProvider.WEBCHAT:
+			return webchatRequestConverter(item);
+		case ChatGatewayProvider.MESSENGER:
+			return messengerRequestConverter(item);
+		case ChatGatewayProvider.VIBER:
+			return viberRequestConverter(item);
+		default:
+			return item;
+	}
+};
+
+const getChatGatewayList = async (params) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const defaultObject = {
+		// default object prototype, to merge response with it to get all fields
+		enabled: false,
+		name: '',
+		uri: '',
+		flow: {},
+		provider: '',
+		metadata: {},
+		updates: {
+			title: '',
+			close: '',
+			join: '',
+			left: '',
+		},
+	};
+
+	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: applyTransform(items, [mergeEach(defaultObject)]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getChatGateway = async ({ itemId: id }) => {
+	const itemResponseHandler = (response) => {
+		switch (response.provider) {
+			case ChatGatewayProvider.WEBCHAT:
+				return webChatResponseConverter(response);
+			case ChatGatewayProvider.MESSENGER:
+				return messengerResponseConverter(response);
+			case ChatGatewayProvider.VIBER:
+				return viberResponseConverter(response);
+			default:
+				return 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 addChatGateway = 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 updateChatGateway = 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 patchChatGateway = 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 deleteChatGateway = async ({ id }) => {
+	const url = `${baseUrl}/${id}`;
+	try {
+		const response = await instance.delete(url);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getLookup = (params) =>
+	getChatGatewayList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+/**
+ * Chat Gateways API for managing chat gateway configurations
+ */
+export const ChatGatewaysAPI = {
+	getList: getChatGatewayList,
+	get: getChatGateway,
+	add: addChatGateway,
+	patch: patchChatGateway,
+	update: updateChatGateway,
+	delete: deleteChatGateway,
+	getLookup,
+};

package/src/api/clients/chatGateways/defaults/defaultChatGateway.ts

@@ -0,0 +1,20 @@
+import { generateUri } from '../scripts/generateUri';
+
+/**
+ * Creates a default chat gateway configuration
+ * @returns Default chat gateway object
+ */
+export const defaultChatGateway = () => ({
+	name: '',
+	uri: generateUri(),
+	flow: {},
+	enabled: false,
+	provider: '',
+	metadata: {},
+	updates: {
+		title: '',
+		close: '',
+		join: '',
+		left: '',
+	},
+});

package/src/api/clients/chatGateways/defaults/webChatGateway.ts

@@ -0,0 +1,75 @@
+import ChatGatewayProvider from '../../../../enums/ChatGatewayProvider/ChatGatewayProvider.enum';
+import { defaultChatGateway } from '../defaults/defaultChatGateway';
+import { WebchatAlternativeChannel } from '../enums/WebchatAlternativeChannel.enum';
+
+/**
+ * Creates a default webchat gateway configuration
+ * @param _btnCodeDirty - Flag indicating if the "copy code" button should be highlighted
+ * @returns Default webchat gateway object
+ */
+export const webChatGateway = (_btnCodeDirty = false) => ({
+	...defaultChatGateway(),
+	provider: ChatGatewayProvider.WEBCHAT,
+	metadata: {
+		// start: these fields related to chat functionality but should be in metadata for backend
+		allowOrigin: [],
+		readTimeout: '30',
+		writeTimeout: '1',
+		handshakeTimeout: '10',
+		mediaMaxSize: `${10 * 1024 * 1024}`, // 10mb
+		// end
+
+		_btnCodeDirty, // inner flag, if true, btn "copy code" is highlighted
+		view: {
+			borderRadiusStyle: '',
+			lang: 'en',
+			btnOpacity: '',
+			logoUrl: '',
+			accentColor: '',
+			position: '',
+		},
+		captcha: {
+			enabled: false,
+			sitekey: '',
+			secret: '',
+			threshold: 0.5,
+			showFlag: false,
+		},
+		chat: {
+			enabled: true,
+			timeoutIsActive: false,
+			openTimeout: '',
+			url: '',
+		},
+		appointment: {
+			enabled: false,
+			url: '',
+			queue: {},
+			communicationType: {},
+			duration: '30m',
+			days: 3,
+			availableAgents: 1,
+			successTitle: '',
+			successSubtitle: '',
+			showDefaultHeading: true,
+			showEmailField: false,
+			showMessageField: false,
+		},
+		call: {
+			enabled: false,
+			url: '',
+			flow: {},
+			id: '',
+		},
+		alternativeChannels: Object.values(WebchatAlternativeChannel).reduce(
+			(channels, channel) => ({
+				...channels,
+				[channel]: {
+					url: '',
+					enabled: false,
+				},
+			}),
+			{},
+		),
+	},
+});

package/src/api/clients/chatGateways/enums/WebchatAlternativeChannel.enum.ts

@@ -0,0 +1,12 @@
+/**
+ * Difference between MessangerType enum and WebchatAlternativeChannel:
+ * MessangerType - backend fields naming, provider
+ * WebchatAlternativeChannel - front-end only "simple" channel naming
+ */
+export const WebchatAlternativeChannel = Object.freeze({
+	VIBER: 'viber',
+	WHATSAPP: 'whatsapp',
+	TELEGRAM: 'telegram',
+	MESSENGER: 'messenger',
+	EMAIL: 'email',
+});

package/src/api/clients/chatGateways/scripts/generateUri.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates a random URI for chat gateways
+ * @returns A random URI string
+ */
+export const generateUri = () => {
+	const length = 31;
+	const charset = 'abcdefghijklmnopqrstuvwxyz';
+	let value = '/';
+	for (let i = 0; i < length; i += 1) {
+		value += charset.charAt(Math.floor(Math.random() * charset.length));
+	}
+	return value;
+};