@webitel/api-services 0.0.24 → 0.0.27

package/src/api/clients//321/201ontacts/contacts.ts

@@ -0,0 +1,337 @@
+import deepCopy from 'deep-copy';
+import { ContactsApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers/index';
+import ContactsSearchMode from './enums/ContactsSearchMode';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const contactService = ContactsApiFactory(configuration, '', instance);
+
+const formatAccessMode = (item) => ({
+	...item,
+	access: {
+		edit: item.mode.includes('w'),
+		delete: item.mode.includes('d'),
+	},
+});
+
+const getList = async (params) => {
+	const fieldsToSend = [
+		'page',
+		'size',
+		'q',
+		'sort',
+		'fields',
+		'id',
+		'qin',
+		'notIdGroup',
+		'group',
+		'owner',
+		'label',
+		'user',
+	];
+
+	if (!params.fields) {
+		params.fields = [
+			'id',
+			'etag',
+			'name',
+			'managers',
+			'labels',
+			'about',
+			'variables',
+			'timezones',
+			'phones',
+			'emails',
+			'imclients',
+		];
+	}
+
+	const listResponseHandler = (items) =>
+		items?.map((item) => ({
+			...item,
+			name: item.name.commonName,
+			managers: item.managers ? [...item.managers.data] : [],
+			labels: item.labels ? [...item.labels.data] : [],
+			groups: getGroupsFromResponse(item),
+			variables: item.variables ? [...item.variables.data] : [],
+			timezones: item.timezones ? [...item.timezones.data] : [],
+			phones: item.phones ? [...item.phones.data] : [],
+			emails: item.emails ? [...item.emails.data] : [],
+		}));
+
+	let changedParams;
+
+	if (params?.search) {
+		changedParams = { ...params, q: params.search };
+	} else if (params?.q && params?.qin) {
+		changedParams = { ...params };
+	} else {
+		let searchValue = '';
+		let searchKey = '';
+
+		if (params[ContactsSearchMode.NAME]) {
+			searchValue = params[ContactsSearchMode.NAME];
+			searchKey = ContactsSearchMode.NAME;
+		} else if (params[ContactsSearchMode.LABELS]) {
+			searchValue = params[ContactsSearchMode.LABELS];
+			searchKey = ContactsSearchMode.LABELS;
+		} else if (params[ContactsSearchMode.ABOUT]) {
+			searchValue = params[ContactsSearchMode.ABOUT];
+			searchKey = ContactsSearchMode.ABOUT;
+		} else if (params[ContactsSearchMode.VARIABLES]) {
+			searchValue = params[ContactsSearchMode.VARIABLES];
+			searchKey = ContactsSearchMode.VARIABLES;
+		} else if (params[ContactsSearchMode.DESTINATION]) {
+			searchValue = params[ContactsSearchMode.DESTINATION];
+			searchKey = 'emails,phones,imclients{user{name}}';
+		}
+
+		// This code needed for adding starToSearch method to applyTransform while searchKey !== SearchMode.VARIABLES because '*' in variables search mode brokes backend logic.
+		// if (searchKey !== ContactsSearchMode.VARIABLES) {
+		//   transformations.push(starToSearch('q')); WTEL-4265
+		// }
+
+		changedParams = {
+			...params,
+			q: searchValue || '',
+			qin: searchKey || '',
+		};
+
+		if (params.hasUser != null) {
+			changedParams.user = params.hasUser;
+		}
+
+		if (params.contactGroup) {
+			changedParams.group = [...params.contactGroup.list];
+		}
+		if (params.contactLabel) {
+			changedParams.label = params.contactLabel.map((item) => item.label);
+		}
+		if (params.contactOwner) {
+			changedParams.owner = params.contactOwner;
+		}
+	}
+
+	if (params.parentId) {
+		changedParams.group = [params.parentId];
+	}
+
+	const transformations = [
+		sanitize(fieldsToSend),
+		merge(getDefaultGetParams()),
+		camelToSnake(),
+	];
+
+	const {
+		page,
+		size,
+		q,
+		sort,
+		fields,
+		id,
+		qin,
+		mode,
+		group_id,
+		group,
+		not_id_group,
+		owner,
+		label,
+		user,
+	} = applyTransform(changedParams, transformations);
+
+	try {
+		const response = await contactService.searchContacts(
+			page,
+			size,
+			q,
+			sort || '+name',
+			['mode', ...fields],
+			id,
+			qin,
+			mode,
+			not_id_group,
+			group,
+			owner,
+			label,
+			user,
+		);
+
+		const { items, next } = applyTransform(
+			{ ...response.data, items: response.data.data || [] },
+			[snakeToCamel(['custom']), merge(getDefaultGetListResponse())],
+		);
+
+		return {
+			items: applyTransform(items, [
+				(items) => items?.map((item) => formatAccessMode(item)),
+				listResponseHandler,
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const get = async ({ itemId: id }) => {
+	const fields = [
+		'name',
+		'about',
+		'labels',
+		'groups',
+		'etag',
+		'mode',
+		'managers',
+		'timezones',
+		'variables',
+		'phones',
+		'emails',
+		'imclients',
+		'user',
+		'custom',
+	];
+
+	const defaultObject = {};
+	const itemResponseHandler = (item) => {
+		return {
+			...item,
+			name: item.name.commonName,
+			labels: item.labels ? [...item.labels.data] : [],
+			groups: getGroupsFromResponse(item),
+			managers: item.managers ? [...item.managers.data] : [],
+			timezones: item.timezones ? [...item.timezones.data] : [],
+			variables: item.variables ? [...item.variables.data] : [],
+			phones: item.phones ? [...item.phones.data] : [],
+			emails: item.emails ? [...item.emails.data] : [],
+		};
+	};
+	try {
+		const response = await contactService.locateContact(id, fields);
+		return applyTransform(response.data, [
+			snakeToCamel(['custom']),
+			merge(defaultObject),
+			itemResponseHandler,
+			formatAccessMode,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = [
+	'name',
+	'labels',
+	'about',
+	'managers',
+	'timezones',
+	'groups',
+	'custom',
+];
+
+const sanitizeManagers = (itemInstance) => {
+	// handle many managers and even no managers field cases
+	const managers = (itemInstance.managers || []).filter(
+		({ user } = {}) => user.id,
+	);
+	return { ...itemInstance, managers };
+};
+
+const sanitizeTimezones = (itemInstance) => {
+	// handle many timezones and even no timezones field cases
+	const timezones = (itemInstance.timezones || []).filter(
+		({ timezone } = {}) => timezone.id,
+	);
+	return { ...itemInstance, timezones };
+};
+
+const sanitizeGroups = (itemInstance) => {
+	// handle many groups and even no groups field cases
+	const groups = (itemInstance.groups || []).map((item) => ({ group: item }));
+	return { ...itemInstance, groups };
+};
+
+const preRequestHandler = (item) => {
+	const copy = deepCopy(item);
+	copy.name = {
+		commonName: copy.name,
+	};
+	return copy;
+};
+
+const getGroupsFromResponse = (item) => {
+	return item.groups ? [...item.groups.data.map((el) => el.group)] : [];
+};
+
+const add = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitizeManagers,
+		sanitizeTimezones,
+		sanitizeGroups,
+		sanitize(fieldsToSend),
+		camelToSnake(['custom']),
+	]);
+	try {
+		const response = await contactService.createContact(item);
+		return applyTransform(response.data, [snakeToCamel(['custom'])]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const update = async ({ itemInstance }) => {
+	const { etag } = itemInstance;
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitizeManagers,
+		sanitizeTimezones,
+		sanitizeGroups,
+		sanitize(fieldsToSend),
+		camelToSnake(['custom']),
+	]);
+	try {
+		const response = await contactService.updateContact(etag, item);
+		return applyTransform(response.data, [snakeToCamel(['custom'])]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteContact = async ({ id }) => {
+	try {
+		const response = await contactService.deleteContact(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getContactsLookup = (params) =>
+	getList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const ContactsAPI = {
+	getList,
+	get,
+	add,
+	update,
+	delete: deleteContact,
+	getLookup: getContactsLookup,
+};

package/src/api/clients//321/201ontacts/enums/ContactsSearchMode.ts

@@ -0,0 +1,9 @@
+const ContactsSearchMode = Object.freeze({
+	NAME: 'name',
+	LABELS: 'labels',
+	ABOUT: 'about',
+	VARIABLES: 'variables',
+	DESTINATION: 'destination',
+});
+
+export default ContactsSearchMode;

package/src/api/clients//321/201ontacts/index.ts

@@ -0,0 +1,5 @@
+import contactChatMessagesHistory from './contactChatMessagesHistory';
+import contacts from './contacts';
+import ContactsSearchMode from './enums/ContactsSearchMode';
+
+export { contactChatMessagesHistory, contacts, ContactsSearchMode };

package/src/api/defaults/getDefaultGetListResponse/getDefaultGetListResponse.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a default response object for list operations
+ * @returns Default list response object with empty items array and next=false
+ */
+export const getDefaultGetListResponse = ({} = {}) => ({
+	items: [],
+	next: false,
+});

package/src/api/defaults/getDefaultGetParams/getDefaultGetParams.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates default parameters for get operations with pagination
+ * @param options - Options for the parameters
+ * @param options.page - Page number (default: 1)
+ * @param options.size - Page size (default: 10)
+ * @returns Default parameters object with page and size
+ */
+export const getDefaultGetParams = ({ page = 1, size = 10 } = {}) => ({
+	page,
+	size,
+});

package/src/api/defaults/getDefaultInstance/getDefaultInstance.ts

@@ -0,0 +1,21 @@
+import qs from 'qs';
+import { generateInstance } from '../../axios/generateInstance';
+import { updateTokenInterceptor } from '../../interceptors/request/updateToken.interceptor';
+import { handleUnauthorizedInterceptor } from '../../interceptors/response/handleUnauthorized.interceptor';
+
+/**
+ * Creates a default Axios instance with standard configuration
+ * @returns Configured Axios instance
+ */
+export const getDefaultInstance = () => {
+	return generateInstance({
+		interceptors: {
+			request: [updateTokenInterceptor],
+			response: [handleUnauthorizedInterceptor],
+		},
+		baseURL: import.meta.env.VITE_API_URL,
+		paramsSerializer: (params) => {
+			return qs.stringify(params);
+		},
+	});
+};

package/src/api/defaults/getDefaultOpenAPIConfig/getDefaultOpenAPIConfig.ts

@@ -0,0 +1,12 @@
+import { Configuration } from 'webitel-sdk';
+
+/**
+ * Creates a default configuration for OpenAPI clients
+ * @returns Configuration object with basePath, apiKey, and accessToken
+ */
+export const getDefaultOpenAPIConfig = () =>
+	new Configuration({
+		basePath: import.meta.env.VITE_API_URL,
+		apiKey: localStorage.getItem('access-key') || '',
+		accessToken: localStorage.getItem('access-key') || '',
+	});

package/src/api/defaults/index.ts

@@ -0,0 +1,11 @@
+import getDefaultGetListResponse from './getDefaultGetListResponse/getDefaultGetListResponse';
+import getDefaultGetParams from './getDefaultGetParams/getDefaultGetParams';
+import getDefaultInstance from './getDefaultInstance/getDefaultInstance';
+import getDefaultOpenAPIConfig from './getDefaultOpenAPIConfig/getDefaultOpenAPIConfig';
+
+export {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+};

package/src/api/index.ts

@@ -0,0 +1,6 @@
+// Export all nested directories' contents
+export * from './axios';
+export * from './clients';
+export * from './defaults';
+export * from './interceptors';
+export * from './transformers';

package/src/api/interceptors/index.ts

@@ -0,0 +1,3 @@
+// Export interceptors
+export * from './request';
+export * from './response';

package/src/api/interceptors/request/index.ts

@@ -0,0 +1,2 @@
+// Export request interceptors
+export { default as updateTokenInterceptor } from './updateToken.interceptor';

package/src/api/interceptors/request/updateToken.interceptor.ts

@@ -0,0 +1,11 @@
+/**
+ * Axios request interceptor that updates the X-Webitel-Access header with the current access token
+ */
+export const updateTokenInterceptor = [
+	(config) => {
+		config.headers['X-Webitel-Access'] =
+			localStorage.getItem('access-token') || '';
+		return config;
+	},
+	(error) => Promise.reject(error),
+];

package/src/api/interceptors/response/handleUnauthorized.interceptor.ts

@@ -0,0 +1,14 @@
+/**
+ * Axios response interceptor that handles 401 Unauthorized responses
+ * by removing the access token from localStorage
+ */
+export const handleUnauthorizedInterceptor = [
+	(response) => response,
+	(error) => {
+		if (error.response && error.response.status === 401) {
+			console.warn('intercepted 401');
+			localStorage.removeItem('access-token');
+		}
+		return Promise.reject(error);
+	},
+];

package/src/api/interceptors/response/index.ts

@@ -0,0 +1,2 @@
+// Export response interceptors
+export { default as handleUnauthorizedInterceptor } from './handleUnauthorized.interceptor';

package/src/api/transformers/addQueryParamsToUrl/addQueryParamsToUrl.transformer.ts

@@ -0,0 +1,19 @@
+// @author @stanislav-kozak
+// This function adds query parameters to a given URL.
+// Where queryArray is an array of query parameters in the format 'key=value'.
+const addQueryParamsToUrl = (queryArray) => (url) => {
+	let modifyUrl = url;
+
+	if (queryArray && queryArray.length > 0) {
+		if (modifyUrl.includes('?')) {
+			modifyUrl += `&${queryArray.join('&')}`;
+
+			return modifyUrl;
+		}
+
+		modifyUrl += `?${queryArray.join('&')}`;
+	}
+
+	return modifyUrl;
+};
+export default addQueryParamsToUrl;

package/src/api/transformers/applyTransform.ts

@@ -0,0 +1,24 @@
+/**
+ * Applies a series of transformers to a target object
+ * @param target - The object to transform
+ * @param transformers - Array of transformer functions to apply
+ * @param options - Configuration options
+ * @param options.debug - Whether to log debug information
+ * @param options.withContext - Context to pass to transformers
+ * @returns The transformed object
+ */
+export const applyTransform = (
+	target,
+	transformers,
+	{ debug = false, withContext = null } = {},
+) => {
+	return transformers.reduce((result, transformer, index) => {
+		if (debug) console.info(`applyTransform debug on step ${index}`, result);
+
+		if (withContext) {
+			return transformer(result, withContext);
+		}
+
+		return transformer(result);
+	}, target);
+};

package/src/api/transformers/camelToSnake/camelToSnake.transformer.ts

@@ -0,0 +1,5 @@
+import { objCamelToSnake } from '../../../scripts/caseConverters';
+
+const camelToSnakeTransformer = (skipKeys) => (obj) =>
+	objCamelToSnake(obj, skipKeys);
+export default camelToSnakeTransformer;

package/src/api/transformers/generateUrl/generateUrl.transformer.ts

@@ -0,0 +1,13 @@
+import qs from 'query-string';
+
+const generateUrlTransformer = (baseUrl) => (params) => {
+	const stringifyOptions = {
+		skipEmptyString: true,
+		skipNull: true,
+	};
+
+	const url = `${baseUrl}?${qs.stringify(params, stringifyOptions)}`;
+	return url;
+};
+
+export default generateUrlTransformer;

package/src/api/transformers/index.ts

@@ -0,0 +1,27 @@
+import addQueryParamsToUrl from './addQueryParamsToUrl/addQueryParamsToUrl.transformer';
+import { applyTransform } from './applyTransform';
+import camelToSnake from './camelToSnake/camelToSnake.transformer';
+import generateUrl from './generateUrl/generateUrl.transformer';
+import log from './log/log.transformer';
+import merge from './merge/merge.transformer';
+import mergeEach from './mergeEach/mergeEach.transformer';
+import notify from './notify/notify.transformer';
+import sanitize from './sanitize/sanitize.transformer';
+import { skipIf } from './skipIf/skipIf';
+import snakeToCamel from './snakeToCamel/snakeToCamel.transformer';
+import starToSearch from './starToSearch/starToSearch.transformer';
+
+export {
+	addQueryParamsToUrl,
+	applyTransform,
+	camelToSnake,
+	generateUrl,
+	log,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	skipIf,
+	snakeToCamel,
+	starToSearch,
+};

package/src/api/transformers/log/log.transformer.ts

@@ -0,0 +1,6 @@
+const logTransformer = (arg) => {
+	console.log(arg);
+	return arg;
+};
+
+export default logTransformer;

package/src/api/transformers/merge/merge.transformer.ts

@@ -0,0 +1,8 @@
+import merge from 'deepmerge';
+
+const mergeTransformer =
+	(...args) =>
+	(main) =>
+		merge.all([...args, main]);
+
+export default mergeTransformer;

package/src/api/transformers/mergeEach/mergeEach.transformer.ts

@@ -0,0 +1,8 @@
+import merge from 'deepmerge';
+
+const mergeEachTransformer =
+	(...args) =>
+	(main) =>
+		main.map((item) => merge.all([...args, item]));
+
+export default mergeEachTransformer;

package/src/api/transformers/notify/notify.transformer.ts

@@ -0,0 +1,39 @@
+import eventBus from '../../../scripts/eventBus';
+
+const notifyTransformer = (notificationObject) => {
+	/*
+  if passed arg is function, then this notification - static content,
+  predefined before actual transformer is called in applyTransform flow
+   */
+	if (typeof notificationObject === 'function') {
+		/*
+    so, create a callback which will send notification with params, passed to it
+     */
+		const callback = ({ type, text }) =>
+			eventBus.$emit('notification', {
+				type,
+				text,
+			});
+
+		/*
+    and, then, return a function, which will be called in main applyTransform flow,
+    calling passed arg function with callback, and returning actual notify payload
+     */
+		return (payload) => {
+			notificationObject({ callback });
+			return payload;
+		};
+	}
+	if (notificationObject instanceof Error) {
+		eventBus.$emit('notification', {
+			type: 'error',
+			text:
+				notificationObject.response?.data?.detail ||
+				notificationObject.response?.data?.message ||
+				notificationObject,
+		});
+	}
+	return notificationObject;
+};
+
+export default notifyTransformer;

package/src/api/transformers/sanitize/sanitize.transformer.ts

@@ -0,0 +1,12 @@
+const sanitizeTransformer = (fieldsToSend) => (item) => {
+	return Object.keys(item).reduce((sanitizedItem, key) => {
+		if (fieldsToSend.indexOf(key) === -1) return sanitizedItem;
+
+		return {
+			...sanitizedItem,
+			[key]: item[key],
+		};
+	}, {});
+};
+
+export default sanitizeTransformer;

package/src/api/transformers/skipIf/skipIf.ts

@@ -0,0 +1,11 @@
+export const skipIf =
+	(
+		transformer: (...payload: unknown[]) => unknown,
+		ifFn: boolean | ((...payload: unknown[]) => boolean),
+	) =>
+	(payload: unknown) => {
+		if (typeof ifFn === 'function' ? ifFn(payload) : ifFn) {
+			return payload;
+		}
+		return transformer(payload);
+	};

package/src/api/transformers/snakeToCamel/snakeToCamel.transformer.ts

@@ -0,0 +1,5 @@
+import { objSnakeToCamel } from '../../../scripts/caseConverters';
+
+const snakeToCamelTransformer = (skipKeys) => (obj) =>
+	objSnakeToCamel(obj, skipKeys);
+export default snakeToCamelTransformer;

package/src/api/transformers/starToSearch/starToSearch.transformer.ts

@@ -0,0 +1,15 @@
+import deepcopy from 'deep-copy';
+import get from 'lodash/get';
+
+import updateObject from '../../../scripts/updateObject';
+
+const starToSearchTransformer =
+	(path = 'search') =>
+	(params) => {
+		const copy = deepcopy(params);
+		const value = get(copy, path);
+		if (!value || value.slice(-1) === '*') return copy;
+		return updateObject({ obj: copy, path, value: `${value}*` });
+	};
+
+export default starToSearchTransformer;