@webitel/api-services 0.0.24 → 0.0.27

package/src/api/clients/calendars/calendars.ts

@@ -0,0 +1,208 @@
+import deepCopy from 'deep-copy';
+import { CalendarServiceApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const calendarService = CalendarServiceApiFactory(configuration, '', instance);
+
+const getCalendarList = async (params) => {
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await calendarService.searchCalendar(
+			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 getCalendar = async ({ itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		const copy = deepCopy(item);
+		const defaultSingleObject = {
+			name: '',
+			timezone: {},
+			description: '',
+			startAt: Date.now(),
+			endAt: Date.now(),
+			expires: !!(copy.startAt || copy.endAt),
+			accepts: [],
+			excepts: [],
+		};
+
+		copy.accepts = copy.accepts.map((accept) => ({
+			day: accept.day || 0,
+			disabled: accept.disabled || false,
+			start: accept.startTimeOfDay || 0,
+			end: accept.endTimeOfDay || 0,
+		}));
+		if (copy.excepts) {
+			copy.excepts = copy.excepts.map((except) => ({
+				name: except.name || '',
+				date: except.date || 0,
+				repeat: except.repeat || false,
+				working: except.working || false,
+				workStart: except.workStart || null,
+				workStop: except.workStop || null,
+			}));
+		}
+		return { ...defaultSingleObject, ...copy };
+	};
+
+	try {
+		const response = await calendarService.readCalendar(id);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = [
+	'name',
+	'description',
+	'timezone',
+	'startAt',
+	'endAt',
+	'day',
+	'accepts',
+	'excepts',
+	'startTimeOfDay',
+	'endTimeOfDay',
+	'disabled',
+	'date',
+	'repeat',
+	'working',
+	'workStart',
+	'workStop',
+];
+
+const preRequestHandler = (item) => {
+	const copy = deepCopy(item);
+	copy.timezone.offset = undefined;
+	if (!copy.expires) {
+		copy.startAt = undefined;
+		copy.endAt = undefined;
+	}
+
+	copy.accepts = copy.accepts.map((accept) => ({
+		day: accept.day,
+		disabled: accept.disabled,
+		startTimeOfDay: accept.start,
+		endTimeOfDay: accept.end,
+	}));
+	return copy;
+};
+
+const addCalendar = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await calendarService.createCalendar(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateCalendar = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await calendarService.updateCalendar(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteCalendar = async ({ id }) => {
+	try {
+		const response = await calendarService.deleteCalendar(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getCalendarsLookup = (params) =>
+	getCalendarList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+const getTimezonesLookup = async (params) => {
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await calendarService.searchTimezones(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+export const CalendarsAPI = {
+	getList: getCalendarList,
+	get: getCalendar,
+	add: addCalendar,
+	update: updateCalendar,
+	delete: deleteCalendar,
+	getLookup: getCalendarsLookup,
+	getTimezonesLookup,
+};

package/src/api/clients/caseCloseReasonGroups/caseCloseReasonGroups.ts

@@ -0,0 +1,126 @@
+import { CloseReasonGroupsApiFactory } 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 closeReasonGroupsService = CloseReasonGroupsApiFactory(
+	configuration,
+	'',
+	instance,
+);
+
+const fieldsToSend = ['name', 'description'];
+
+const getCloseReasonGroupsList = 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 closeReasonGroupsService.listCloseReasonGroups(
+			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 getCloseReasonGroups = async ({ itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		return item.closeReasonGroup;
+	};
+
+	try {
+		const response = await closeReasonGroupsService.locateCloseReasonGroup(
+			id,
+			fieldsToSend,
+		);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addCloseReasonGroups = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response =
+			await closeReasonGroupsService.createCloseReasonGroup(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateCloseReasonGroups = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+	try {
+		const response = await closeReasonGroupsService.updateCloseReasonGroup(
+			id,
+			item,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteCloseReasonGroups = async ({ id }) => {
+	try {
+		const response = await closeReasonGroupsService.deleteCloseReasonGroup(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getCloseReasonGroupsLookup = async (params) =>
+	getCloseReasonGroupsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const CaseCloseReasonGroupsAPI = {
+	getList: getCloseReasonGroupsList,
+	get: getCloseReasonGroups,
+	add: addCloseReasonGroups,
+	update: updateCloseReasonGroups,
+	delete: deleteCloseReasonGroups,
+	getLookup: getCloseReasonGroupsLookup,
+};

package/src/api/clients/caseCloseReasons/caseCloseReasons.ts

@@ -0,0 +1,122 @@
+import { CloseReasonsApiFactory } 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 closeReasonsService = CloseReasonsApiFactory(configuration, '', instance);
+
+const fieldsToSend = ['name', 'description'];
+
+const getCloseReasonsList = async ({ parentId, ...rest }) => {
+	const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+	const { page, size, fields, sort, id, q } = applyTransform(rest, [
+		merge(getDefaultGetParams()),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await closeReasonsService.listCloseReasons(
+			parentId,
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q,
+		);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [snakeToCamel()]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getCloseReason = async ({ parentId, itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		return item.closeReason;
+	};
+
+	try {
+		const response = await closeReasonsService.locateCloseReason(parentId, id);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addCloseReason = async ({ itemInstance, parentId }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await closeReasonsService.createCloseReason(
+			parentId,
+			item,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateCloseReason = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [camelToSnake()]);
+
+	try {
+		const response = await closeReasonsService.updateCloseReason(
+			itemInstance.id,
+			id,
+			item,
+		);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteCloseReason = async ({ id, parentId }) => {
+	try {
+		const response = await closeReasonsService.deleteCloseReason(parentId, id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getCloseReasonLookup = async (params) =>
+	getCloseReasonsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const CaseCloseReasonsAPI = {
+	getList: getCloseReasonsList,
+	getLookup: getCloseReasonLookup,
+	get: getCloseReason,
+	add: addCloseReason,
+	update: updateCloseReason,
+	delete: deleteCloseReason,
+};

package/src/api/clients/casePriorities/casePriorities.ts

@@ -0,0 +1,137 @@
+import { PrioritiesApiFactory } 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 priorityService = PrioritiesApiFactory(configuration, '', instance);
+
+const fieldsToSend = ['name', 'description', 'color'];
+
+const getPrioritiesList = async (params) => {
+	const fieldsToSend = [
+		'page',
+		'size',
+		'q',
+		'sort',
+		'fields',
+		'id',
+		'notInSla',
+		'inSla',
+		'inSlaCond',
+	];
+	const {
+		page,
+		size,
+		fields,
+		sort,
+		id,
+		q,
+		not_in_sla: notInSla,
+		in_sla_cond: inSlaCond,
+	} = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await priorityService.listPriorities(
+			page,
+			size,
+			fields,
+			sort,
+			id,
+			q,
+			notInSla,
+			inSlaCond,
+		);
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, []),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getPriority = async ({ itemId: id }) => {
+	const itemResponseHandler = (item) => {
+		return item.priority;
+	};
+
+	try {
+		const response = await priorityService.locatePriority(id, fieldsToSend);
+		return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const addPriority = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await priorityService.createPriority(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updatePriority = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
+
+	try {
+		const response = await priorityService.updatePriority(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deletePriority = async ({ id }) => {
+	try {
+		const response = await priorityService.deletePriority(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getConditionsLookup = (params) =>
+	getPrioritiesList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const CasePrioritiesAPI = {
+	getList: getPrioritiesList,
+	get: getPriority,
+	update: updatePriority,
+	getLookup: getConditionsLookup,
+	delete: deletePriority,
+	add: addPriority,
+};