@webitel/api-services 0.0.24 → 0.0.27

package/src/api/clients/users/users.ts

@@ -0,0 +1,228 @@
+import deepCopy from 'deep-copy';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	generateUrl,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers/index';
+import { generatePermissionsApi } from '../_shared/generatePermissionsApi';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/users';
+const fieldsToSend = [
+	'name',
+	'username',
+	'password',
+	'extension',
+	'status',
+	'note',
+	'roles',
+	'license',
+	'devices',
+	'device',
+	'profile',
+	'email',
+	'contact',
+	'chatName',
+];
+
+const getUsersList = async (params) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const defaultObject = {
+		name: '',
+		status: '',
+		state: true,
+		dnd: false,
+	};
+
+	const url = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+		generateUrl(baseUrl),
+	]);
+	try {
+		const response = await instance.get(url);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(['profile']),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [mergeEach(defaultObject)]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getUser = async ({ itemId: id }) => {
+	const defaultObject = {
+		roles: [],
+		license: [],
+		devices: [],
+		device: {},
+		variables: [{ key: '', value: '' }],
+	};
+
+	const itemResponseHandler = (item) => {
+		const copy = deepCopy(item);
+		if (copy.license) {
+			copy.license.forEach((item) => {
+				item.name = item.prod;
+			});
+		}
+		if (copy.profile) {
+			copy.variables = Object.keys(copy.profile).map((key) => ({
+				key,
+				value: copy.profile[key],
+			}));
+		} else {
+			copy.variables = [{ key: '', value: '' }];
+		}
+		return copy;
+	};
+
+	const url = `${baseUrl}/${id}`;
+
+	try {
+		const response = await instance.get(url);
+		return applyTransform(response.data, [
+			snakeToCamel(['profile']),
+			merge(defaultObject),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const preRequestHandler = (item) => {
+	const copy = deepCopy(item);
+	if (item.device && !item.device.id) copy.device = undefined;
+
+	if (copy.roles) copy.roles.forEach((copy) => (copy.text = undefined));
+
+	if (copy.devices) copy.devices.forEach((copy) => (copy.text = undefined));
+	if (copy.license) {
+		copy.license = copy.license.map((copy) => ({ id: copy.id }));
+	}
+	copy.profile = {};
+	if (copy.variables) {
+		copy.variables.forEach((variable) => {
+			copy.profile[variable.key] = variable.value;
+		});
+	}
+	return copy;
+};
+
+const addUser = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(['profile']),
+	]);
+	try {
+		const response = await instance.post(baseUrl, item);
+		return applyTransform(response.data, [snakeToCamel(['profile'])]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateUser = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(['profile']),
+	]);
+
+	const url = `${baseUrl}/${id}`;
+	try {
+		const response = await instance.put(url, item);
+		return applyTransform(response.data, [snakeToCamel(['profile'])]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchUser = async ({ changes, id }) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(['profile']),
+	]);
+	const url = `${baseUrl}/${id}`;
+	try {
+		const response = await instance.patch(url, body);
+		return applyTransform(response.data, [snakeToCamel(['profile'])]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchUserPresence = async ({ changes, id }) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(['profile']),
+	]);
+	const url = `${baseUrl}/${id}/presence`;
+	try {
+		const response = await instance.patch(url, body);
+		return applyTransform(response.data, [snakeToCamel(['profile'])]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteUser = async ({ id }) => {
+	const url = `${baseUrl}/${id}?permanent=true`;
+	// permanent=true for complete deletion
+	try {
+		const response = await instance.delete(url);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getUsersLookup = (params) =>
+	getUsersList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+const logoutUser = async ({ id }) => {
+	const url = `${baseUrl}/${id}/logout`;
+	try {
+		const response = await instance.post(url, {});
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const UsersAPI = {
+	getList: getUsersList,
+	get: getUser,
+	add: addUser,
+	patch: patchUser,
+	update: updateUser,
+	delete: deleteUser,
+	getLookup: getUsersLookup,
+	patchUserPresence,
+	logoutUser,
+
+	...generatePermissionsApi(baseUrl),
+};

package/src/api/clients/wtTypes/_shared/utils/sortDynamicFields.ts

@@ -0,0 +1,21 @@
+import deepCopy from 'deep-copy';
+import type { WebitelProtoDataStruct } from 'webitel-sdk';
+
+export const sortDynamicFields = (
+	item: WebitelProtoDataStruct,
+): WebitelProtoDataStruct => {
+	const unSortableFields = item.fields.filter((field) => !field.position);
+
+	const sortableFields = deepCopy(item.fields)
+		.filter((field) => field.position)
+		.sort((a, b) => {
+			return a.position - b.position;
+		});
+
+	const fields = [...unSortableFields, ...sortableFields];
+
+	return {
+		...item,
+		fields,
+	};
+};

package/src/api/clients/wtTypes/sysTypes/sysTypes.ts

@@ -0,0 +1,60 @@
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+} from '../../../defaults';
+import applyTransform, {
+	camelToSnake,
+	generateUrl,
+	merge,
+	notify,
+	sanitize,
+	starToSearch,
+} from '../../../transformers';
+
+const instance = getDefaultInstance();
+
+const getSysTypeRecordsList = async ({ path, display, primary, ...params }) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id', 'ids'];
+
+	const url = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		(params) => ({ ...params, q: params.search }),
+		(params) => ({
+			...params,
+			ids: params.id /* https://webitel.atlassian.net/browse/WTEL-6788 */,
+		}),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+		generateUrl(path),
+	]);
+	try {
+		const response = await instance.get(url);
+		const { data, items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+
+		return {
+			// Some endpoints return data, some return items so we need to check for both of them
+			items:
+				applyTransform(data || items, [
+					// transformItemsForSelect({ display, primary }),
+				]) ?? [],
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getSysTypeRecordsLookup = (params) =>
+	getSysTypeRecordsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const SysTypesAPI = {
+	getList: getSysTypeRecordsList,
+	getLookup: getSysTypeRecordsLookup,
+};

package/src/api/clients/wtTypes/typeExtensions/typeExtensions.ts

@@ -0,0 +1,114 @@
+import { ExtensionsApiFactory, type WebitelProtoDataStruct } from 'webitel-sdk';
+
+import { getDefaultInstance, getDefaultOpenAPIConfig } from '../../../defaults';
+import applyTransform, {
+	camelToSnake,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../../transformers';
+import { sortDynamicFields } from '../_shared/utils/sortDynamicFields';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const typeExtensionsService = ExtensionsApiFactory(configuration, '', instance);
+
+const fieldsToSend = ['fields', 'repo', 'path'];
+
+const generateIdsFromRepos = (item: WebitelProtoDataStruct) => ({
+	...item,
+	id: item.repo,
+});
+
+const getTypeExtension = async ({ itemId: typeRepo }) => {
+	const createPositionGenerator = () => {
+		let position = 1;
+		return (item) => (item.readonly ? null : position++);
+	};
+	const getPosition = createPositionGenerator();
+
+	const itemResponseHandler = (item) => ({
+		...item,
+		fields: item.fields.map((field) => ({
+			...field,
+			position: getPosition(field),
+		})),
+	});
+
+	try {
+		const response = await typeExtensionsService.locateType(typeRepo);
+
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			generateIdsFromRepos,
+			itemResponseHandler,
+		]);
+	} catch {
+		return {
+			id: typeRepo,
+			fields: [],
+			isNew: true,
+		};
+	}
+};
+
+const addTypeExtension = async ({ itemInstance, itemId: typeRepo }) => {
+	const item = applyTransform(itemInstance, [
+		sortDynamicFields,
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await typeExtensionsService.createType(typeRepo, item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			generateIdsFromRepos,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteTypeExtension = async ({ itemId: typeRepo }) => {
+	try {
+		await typeExtensionsService.deleteType(typeRepo);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateTypeExtension = async ({ itemInstance, itemId: typeRepo }) => {
+	if (!itemInstance.fields.length && itemInstance.isNew) {
+		return itemInstance;
+	}
+	if (itemInstance.isNew) {
+		return addTypeExtension({ itemInstance, itemId: typeRepo });
+	}
+
+	if (!itemInstance.fields.length && !itemInstance.isNew) {
+		return deleteTypeExtension({ itemId: typeRepo });
+	}
+
+	const item = applyTransform(itemInstance, [
+		sortDynamicFields,
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await typeExtensionsService.updateType(typeRepo, item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			generateIdsFromRepos,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const WtTypeExtensionApi = {
+	getList: getTypeExtension,
+	add: addTypeExtension,
+	update: updateTypeExtension,
+	delete: deleteTypeExtension,
+};

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

@@ -0,0 +1,98 @@
+import { ContactsChatCatalogApiFactory } from 'webitel-sdk';
+
+import i18n from '../../../locale/i18n';
+import {
+	getDefaultGetListResponse,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	merge,
+	notify,
+	snakeToCamel,
+} from '../../transformers/index';
+
+const { t } = i18n.global;
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const contactChatService = ContactsChatCatalogApiFactory(
+	configuration,
+	'',
+	instance,
+);
+
+const getChat = async ({ contactId, chatId }) => {
+	const mergeChatMessagesData = ({ messages, peers }) => {
+		if (!messages) return [];
+		return messages.map(({ from, ...message }) => {
+			return {
+				...message,
+				peer: peers[from.id - 1],
+			};
+		});
+	};
+
+	try {
+		const response = await contactChatService.getContactChatHistory(
+			contactId,
+			chatId,
+		);
+		const { messages, peers } = applyTransform(response.data, [snakeToCamel()]);
+		return {
+			items: applyTransform({ messages, peers }, [mergeChatMessagesData]),
+			peers,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+// all messages from all contacts chats
+const getAllMessages = async (params) => {
+	const mergeMessagesData = ({ messages, peers, chats }) => {
+		if (!messages) return [];
+		return messages.map(({ from, chat, ...message }) => {
+			return {
+				...message,
+				peer: peers[from.id - 1],
+				chat: chats[chat.id - 1],
+			};
+		});
+	};
+
+	const { contactId, page, size } = params;
+
+	try {
+		const response = await contactChatService.getContactChatHistory2(
+			contactId,
+			undefined,
+			undefined,
+			size,
+			`${page || 1}`,
+		);
+		const { messages, peers, chats, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform({ messages, peers, chats }, [mergeMessagesData]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify(({ callback }) =>
+				callback({
+					type: 'error',
+					text: t('errorNotifications.chatHistoryApi'),
+				}),
+			),
+		]);
+	}
+};
+
+export const ContactChatMessagesAPI = {
+	getChat,
+	getAllMessages,
+};