@webitel/api-services 1.0.10 → 1.0.12

package/src/api/clients/logs/logs.ts

@@ -0,0 +1,157 @@
+import { getLoggerService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type { ApiParams } from '../_shared/types';
+
+/**
+ * The logger endpoints have no natural ordering, so both lists default to
+ * newest first.
+ */
+const DEFAULT_SORT = '-date';
+
+const getLogsByUserList = async (params: ApiParams) => {
+	const fieldsToSend = [
+		'parentId',
+		'page',
+		'size',
+		'search',
+		'sort',
+		'fields',
+		'action',
+		'object',
+		'from',
+		'to',
+		'userIp',
+	];
+
+	const {
+		parentId,
+		page,
+		size,
+		search,
+		sort,
+		fields,
+		action,
+		object,
+		from,
+		to,
+		userIp,
+	} = applyTransform(params, [
+		sanitize(fieldsToSend),
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await getLoggerService().loggerServiceSearchLogByUserId(
+			Number(parentId),
+			{
+				page,
+				size,
+				// the generated param is `q`; `search` is what the datalist store sends
+				q: search,
+				sort: sort || DEFAULT_SORT,
+				fields,
+				object_id: object,
+				action,
+				user_ip: userIp,
+				date_from: from,
+				date_to: to,
+			},
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getLogsByConfigList = async (params: ApiParams) => {
+	const fieldsToSend = [
+		'parentId',
+		'page',
+		'size',
+		'search',
+		'sort',
+		'fields',
+		'action',
+		'user',
+		'from',
+		'to',
+		'userIp',
+	];
+
+	const {
+		parentId,
+		page,
+		size,
+		search,
+		sort,
+		fields,
+		action,
+		user,
+		from,
+		to,
+		userIp,
+	} = applyTransform(params, [
+		sanitize(fieldsToSend),
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await getLoggerService().loggerServiceSearchLogByConfigId(
+			Number(parentId),
+			{
+				page,
+				size,
+				// the generated param is `q`; `search` is what the datalist store sends
+				q: search,
+				sort: sort || DEFAULT_SORT,
+				fields,
+				user_id: user,
+				action,
+				user_ip: userIp,
+				date_from: from,
+				date_to: to,
+			},
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+/** Audit log of everything one user did. */
+export const UserLogsAPI = {
+	getList: getLogsByUserList,
+};
+
+/** Audit log of everything done to one logger config's object. */
+export const ConfigLogsAPI = {
+	getList: getLogsByConfigList,
+};

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

@@ -1,15 +1,16 @@
 import axios from 'axios';
-import { MediaFileServiceApiFactory } from 'webitel-sdk';
+import { getMediaFileService } from '../../../gen-wire';
 import {
 	getDefaultGetListResponse,
 	getDefaultGetParams,
 	getDefaultInstance,
-	getDefaultOpenAPIConfig,
 } from '../../defaults';
 import {
 	applyTransform,
+	camelToSnake,
 	merge,
 	notify,
+	sanitize,
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
@@ -21,28 +22,31 @@ import type {
 } from '../_shared/types';
 
 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: ApiParams) => {
-	const { page, size, search, sort, fields, id } = applyTransform(params, [
+	const requestParams = applyTransform(params, [
 		merge(getDefaultGetParams()),
 		starToSearch('search'),
+		camelToSnake(),
+		(params) => ({
+			...params,
+			q: params.search,
+		}),
+		sanitize([
+			'page',
+			'size',
+			'q',
+			'sort',
+			'fields',
+			'id',
+		]),
 	]);
 
 	try {
-		const response = await mediaService.searchMediaFile(
-			page,
-			size,
-			search,
-			sort,
-			fields,
-			id,
-		);
+		const response = await getMediaFileService().searchMediaFile(requestParams);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -137,7 +141,7 @@ const addMedia = async (params: ApiParams) => {
 
 const deleteMedia = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await mediaService.deleteMediaFile(String(id));
+		const response = await getMediaFileService().deleteMediaFile(String(id));
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [

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

@@ -1,9 +1,8 @@
-import { TypesApiFactory } from 'webitel-sdk';
+import { getTypes } from '../../../gen-wire';
 import {
 	getDefaultGetListResponse,
 	getDefaultGetParams,
 	getDefaultInstance,
-	getDefaultOpenAPIConfig,
 } from '../../defaults';
 import {
 	applyTransform,
@@ -18,9 +17,6 @@ import {
 import type { ApiParams } from '../_shared/types';
 
 const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const typeService = TypesApiFactory(configuration, '', instance);
 
 const getObjectList = async (params: ApiParams) => {
 	const fieldsToSend = [
@@ -43,21 +39,14 @@ const getObjectList = async (params: ApiParams) => {
 		camelToSnake(),
 	]);
 	try {
-		const response = await typeService.search(
+		const response = await getTypes().searchTypes({
 			q,
 			id,
-			undefined,
-			undefined,
-			undefined,
-			undefined,
-			undefined,
-			undefined,
-			undefined,
 			size,
 			page,
 			sort,
 			fields,
-		);
+		});
 		const { data, next } = applyTransform(response.data, [
 			merge(getDefaultGetListResponse()),
 		]);

package/src/api/clients/outboundResourceGroups/outboundResourceGroups.ts

@@ -0,0 +1,187 @@
+import deepCopy from 'deep-copy';
+import { getOutboundResourceGroupService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	AddItemParams,
+	ApiParams,
+	DeleteItemParams,
+	GetItemParams,
+	UpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'name',
+	'description',
+	'strategy',
+	'communication',
+	'time',
+];
+
+/*
+ * The form models a time range as `{ start, end }`, the API as
+ * `{ startTimeOfDay, endTimeOfDay }`. `getResourceGroup` maps them back.
+ */
+const preRequestHandler = (item: ApiParams) => {
+	const copy = deepCopy(item);
+	copy.time = copy.time.map((range: ApiParams) => ({
+		startTimeOfDay: range.start,
+		endTimeOfDay: range.end,
+	}));
+	return copy;
+};
+
+const getResourceGroupsList = async (params: ApiParams) => {
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response =
+			await getOutboundResourceGroupService().searchOutboundResourceGroup({
+				page,
+				size,
+				// the generated param is `q`; `search` is what the datalist store sends
+				q: search,
+				sort,
+				fields,
+				id,
+			});
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getResourceGroup = async ({ itemId: id }: GetItemParams) => {
+	const defaultObject = {
+		name: '',
+		strategy: '',
+		description: '',
+		communication: {},
+		time: [],
+	};
+
+	const responseHandler = (response: ApiParams) => {
+		const time = response.time.map((range: ApiParams) => ({
+			start: range.startTimeOfDay || 0,
+			end: range.endTimeOfDay || 0,
+		}));
+		return {
+			...response,
+			time,
+		};
+	};
+
+	try {
+		const response =
+			await getOutboundResourceGroupService().readOutboundResourceGroup(
+				String(id),
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+			responseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addResourceGroup = async ({ itemInstance }: AddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getOutboundResourceGroupService().createOutboundResourceGroup(item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateResourceGroup = async ({
+	itemInstance,
+	itemId: id,
+}: UpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getOutboundResourceGroupService().updateOutboundResourceGroup(
+				String(id),
+				item,
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteResourceGroup = async ({ id }: DeleteItemParams) => {
+	try {
+		const response =
+			await getOutboundResourceGroupService().deleteOutboundResourceGroup(
+				String(id),
+			);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getResourceGroupsLookup = (
+	params: Parameters<typeof getResourceGroupsList>[0],
+) =>
+	getResourceGroupsList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+		],
+	});
+
+export const OutboundResourceGroupsAPI = {
+	getList: getResourceGroupsList,
+	get: getResourceGroup,
+	add: addResourceGroup,
+	update: updateResourceGroup,
+	delete: deleteResourceGroup,
+	getLookup: getResourceGroupsLookup,
+};

package/src/api/clients/outboundResourceGroups/resourcesInGroup.ts

@@ -0,0 +1,169 @@
+import { getOutboundResourceGroupService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	ApiId,
+	ApiParams,
+	NestedAddItemParams,
+	NestedDeleteItemParams,
+	NestedGetItemParams,
+	NestedUpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'groupId',
+	'name',
+	'description',
+	'resource',
+	'reserveResource',
+	'priority',
+];
+
+const preRequestHandler = (parentId: ApiId) => (item: ApiParams) => ({
+	...item,
+	groupId: parentId,
+});
+
+const getResourcesInGroupList = async (params: ApiParams) => {
+	const { page, size, search, sort, fields, id, parentId } = applyTransform(
+		params,
+		[
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+		],
+	);
+
+	try {
+		const response =
+			await getOutboundResourceGroupService().searchOutboundResourceInGroup(
+				String(parentId),
+				{
+					page,
+					size,
+					// the generated param is `q`; `search` is what the datalist store sends
+					q: search,
+					sort,
+					fields,
+					id,
+				},
+			);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getResourceInGroup = async ({
+	parentId,
+	itemId: id,
+}: NestedGetItemParams) => {
+	try {
+		const response =
+			await getOutboundResourceGroupService().readOutboundResourceInGroup(
+				String(parentId),
+				String(id),
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addResourceInGroup = async ({
+	parentId,
+	itemInstance,
+}: NestedAddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getOutboundResourceGroupService().createOutboundResourceInGroup(
+				String(parentId),
+				item,
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateResourceInGroup = async ({
+	parentId,
+	itemInstance,
+	itemId: id,
+}: NestedUpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getOutboundResourceGroupService().updateOutboundResourceInGroup(
+				String(parentId),
+				String(id),
+				item,
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteResourceInGroup = async ({
+	parentId,
+	id,
+}: NestedDeleteItemParams) => {
+	try {
+		const response =
+			await getOutboundResourceGroupService().deleteOutboundResourceInGroup(
+				String(parentId),
+				String(id),
+			);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const ResourcesInGroupAPI = {
+	getList: getResourcesInGroupList,
+	get: getResourceInGroup,
+	add: addResourceInGroup,
+	update: updateResourceInGroup,
+	delete: deleteResourceInGroup,
+};