@webitel/api-services 0.0.25 → 0.0.28

package/src/api/clients/queues/queues.ts

@@ -1,238 +1,233 @@
 import deepCopy from 'deep-copy';
+import { isEmpty } from 'lodash-es';
 import { QueueServiceApiFactory } from 'webitel-sdk';
 
-import isEmpty from '../../../scripts/isEmpty';
 import {
-  getDefaultGetListResponse,
-  getDefaultGetParams,
-  getDefaultInstance,
-  getDefaultOpenAPIConfig,
-} from '../../defaults/index';
-import applyTransform, {
-  camelToSnake,
-  merge,
-  mergeEach,
-  notify,
-  sanitize,
-  snakeToCamel,
-  starToSearch,
-} from '../../transformers/index';
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
 import processing from './defaults/processing';
 
 const instance = getDefaultInstance();
 const configuration = getDefaultOpenAPIConfig();
 
-const queueService = new QueueServiceApiFactory(configuration, '', instance);
+const queueService = QueueServiceApiFactory(configuration, '', instance);
 
 const doNotConvertKeys = ['variables'];
 
 const fieldsToSend = [
-  'name',
-  'type',
-  'strategy',
-  'team',
-  'priority',
-  'dncList',
-  'schema',
-  'payload',
-  'taskProcessing',
-  'maxOfRetry',
-  'timeout',
-  'secBetweenRetries',
-  'variables',
-  'calendar',
-  'description',
-  'enabled',
-  'ringtone',
-  'doSchema',
-  'afterSchema',
-  'stickyAgent',
-  'grantee',
-  'tags',
+	'name',
+	'type',
+	'strategy',
+	'team',
+	'priority',
+	'dncList',
+	'schema',
+	'payload',
+	'taskProcessing',
+	'maxOfRetry',
+	'timeout',
+	'secBetweenRetries',
+	'variables',
+	'calendar',
+	'description',
+	'enabled',
+	'ringtone',
+	'doSchema',
+	'afterSchema',
+	'stickyAgent',
+	'grantee',
+	'tags',
 ];
 
 const preRequestHandler = (item) => {
-  const copy = deepCopy(item);
-  copy.variables = copy.variables.reduce((variables, variable) => {
-    if (!variable.key) return variables;
-    return { ...variables, [variable.key]: variable.value };
-  }, {});
-  return copy;
+	const copy = deepCopy(item);
+	copy.variables = copy.variables.reduce((variables, variable) => {
+		if (!variable.key) return variables;
+		return { ...variables, [variable.key]: variable.value };
+	}, {});
+	return copy;
 };
 
 const getQueuesList = async (params) => {
-  const defaultObject = {
-    type: 0,
-    enabled: false,
-    active: 0,
-    waiting: 0,
-    priority: '0',
-  };
-
-  const { page, size, search, sort, fields, id, queueType, team, tags } =
-    applyTransform(params, [
-      merge(getDefaultGetParams()),
-      starToSearch('search'),
-    ]);
-
-  try {
-    const response = await queueService.searchQueue(
-      page,
-      size,
-      search,
-      sort,
-      fields,
-      id,
-      queueType,
-      team,
-      tags,
-    );
-    const { items, next } = applyTransform(response.data, [
-      snakeToCamel(doNotConvertKeys),
-      merge(getDefaultGetListResponse()),
-    ]);
-    return {
-      items: applyTransform(items, [mergeEach(defaultObject)]),
-      next,
-    };
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	const defaultObject = {
+		type: 0,
+		enabled: false,
+		active: 0,
+		waiting: 0,
+		priority: '0',
+	};
+
+	const { page, size, search, sort, fields, id, queueType, team, tags } =
+		applyTransform(params, [
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+		]);
+
+	try {
+		const response = await queueService.searchQueue(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+			queueType,
+			team,
+			tags,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [mergeEach(defaultObject)]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
 const getQueue = async ({ itemId: id }) => {
-  const defaultObject = {
-    tags: [],
-    type: 0,
-    formSchema: {},
-    taskProcessing: {},
-  };
-  const responseHandler = (item) => {
-    const copy = deepCopy(item);
-    try {
-      if (copy.variables) {
-        copy.variables = Object.keys(copy.variables).map((key) => ({
-          key,
-          value: copy.variables[key],
-        }));
-      }
-      if (isEmpty(copy.taskProcessing)) {
-        copy.taskProcessing = processing({
-          enabled: !!copy.processing,
-          formSchema: copy.formSchema,
-          sec: copy.processingSec || 0,
-          renewalSec: copy.processingRenewalSec || 0,
-        });
-      }
-      return copy;
-    } catch (err) {
-      throw err;
-    }
-  };
-  try {
-    const response = await queueService.readQueue(id);
-    return applyTransform(response.data, [
-      snakeToCamel(doNotConvertKeys),
-      merge(defaultObject),
-      responseHandler,
-    ]);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	const defaultObject = {
+		tags: [],
+		type: 0,
+		formSchema: {},
+		taskProcessing: {},
+	};
+	const responseHandler = (item) => {
+		const copy = deepCopy(item);
+		if (copy.variables) {
+			copy.variables = Object.keys(copy.variables).map((key) => ({
+				key,
+				value: copy.variables[key],
+			}));
+		}
+		if (isEmpty(copy.taskProcessing)) {
+			copy.taskProcessing = processing({
+				enabled: !!copy.processing,
+				formSchema: copy.formSchema,
+				sec: copy.processingSec || 0,
+				renewalSec: copy.processingRenewalSec || 0,
+			});
+		}
+		return copy;
+	};
+	try {
+		const response = await queueService.readQueue(id);
+		return applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(defaultObject),
+			responseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
 const addQueue = async ({ itemInstance }) => {
-  const item = applyTransform(itemInstance, [
-    preRequestHandler,
-    sanitize(fieldsToSend),
-    camelToSnake(doNotConvertKeys),
-  ]);
-  try {
-    const response = await queueService.createQueue(item);
-    return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await queueService.createQueue(item);
+		return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
 const updateQueue = async ({ itemInstance, itemId: id }) => {
-  const item = applyTransform(itemInstance, [
-    preRequestHandler,
-    sanitize(fieldsToSend),
-    camelToSnake(doNotConvertKeys),
-  ]);
-  try {
-    const response = await queueService.updateQueue(id, item);
-    return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await queueService.updateQueue(id, item);
+		return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
 const patchQueue = async ({ id, changes }) => {
-  const item = applyTransform(changes, [
-    sanitize(fieldsToSend),
-    camelToSnake(doNotConvertKeys),
-  ]);
-  try {
-    const response = await queueService.patchQueue(id, item);
-    return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	const item = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await queueService.patchQueue(id, item);
+		return applyTransform(response.data, [snakeToCamel(doNotConvertKeys)]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
 const deleteQueue = async ({ id }) => {
-  try {
-    const response = await queueService.deleteQueue(id);
-    return applyTransform(response.data, []);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	try {
+		const response = await queueService.deleteQueue(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
 const getQueuesLookup = (params) =>
-  getQueuesList({
-    ...params,
-    fields: params.fields || ['id', 'name', 'type'],
-  });
+	getQueuesList({
+		...params,
+		fields: params.fields || ['id', 'name', 'type'],
+	});
 
 const getQueuesTags = async (params) => {
-  const { page, size, search, sort, fields } = applyTransform(params, [
-    merge(getDefaultGetParams()),
-    starToSearch(),
-    camelToSnake(doNotConvertKeys),
-  ]);
-  try {
-    const response = await queueService.searchQueueTags(
-      page,
-      size,
-      search,
-      sort,
-      fields,
-    );
-    const { items, next } = applyTransform(response.data, [
-      snakeToCamel(doNotConvertKeys),
-      merge(getDefaultGetListResponse()),
-    ]);
-    return {
-      items,
-      next,
-    };
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	const { page, size, search, sort, fields } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch(),
+		camelToSnake(doNotConvertKeys),
+	]);
+	try {
+		const response = await queueService.searchQueueTags(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(doNotConvertKeys),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
-const QueuesAPI = {
-  getList: getQueuesList,
-  get: getQueue,
-  add: addQueue,
-  patch: patchQueue,
-  update: updateQueue,
-  delete: deleteQueue,
-  getLookup: getQueuesLookup,
-  getQueuesTags,
+export const QueuesAPI = {
+	getList: getQueuesList,
+	get: getQueue,
+	add: addQueue,
+	patch: patchQueue,
+	update: updateQueue,
+	delete: deleteQueue,
+	getLookup: getQueuesLookup,
+	getQueuesTags,
 };
-
-export default QueuesAPI;

package/src/api/clients/quickReplies/quickReplies.ts

@@ -1,117 +1,104 @@
 import { getQuickRepliesService } from '@webitel/api-services/gen';
 
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
-  getDefaultGetListResponse,
-  getDefaultGetParams,
-} from '../../defaults/index';
-import applyTransform, {
-  camelToSnake,
-  merge,
-  notify,
-  sanitize,
-  snakeToCamel,
-} from '../../transformers/index';
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers';
 
-const quickReplyService = getQuickRepliesService();
-
-const fieldsToSend = [
-  'name',
-  'queues',
-  'article',
-  'teams',
-  'text',
-];
+const fieldsToSend = ['name', 'queues', 'article', 'teams', 'text'];
 
 const getQuickRepliesList = async (params) => {
-  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+	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(),
-  ]);
+	const { page, size, fields, sort, id, q } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		(params) => ({ ...params, q: params.search }),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
 
-  try {
-    const response = await quickReplyService.searchQuickReplies({
-      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]);
-  }
+	try {
+		const response = await getQuickRepliesService().searchQuickReplies({
+			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 getQuickReply = async ({ itemId: id }) => {
-
-  try {
-    const response = await quickReplyService.readQuickReply(id);
-    return applyTransform(response.data, [snakeToCamel()]);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	try {
+		const response = await getQuickRepliesService().readQuickReply(id);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
-const addQuickReply= async ({ itemInstance }) => {
-  const item = applyTransform(itemInstance, [
-    sanitize(fieldsToSend),
-    camelToSnake(),
-  ]);
-  try {
-    const response = await quickReplyService.createQuickReply(item);
-    return applyTransform(response.data, [snakeToCamel()]);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+const addQuickReply = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getQuickRepliesService().createQuickReply(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
-
 const updateQuickReply = async ({ itemInstance, itemId: id }) => {
-  const item = applyTransform(itemInstance, [
-    camelToSnake(),
-    sanitize(fieldsToSend),
-  ]);
+	const item = applyTransform(itemInstance, [
+		camelToSnake(),
+		sanitize(fieldsToSend),
+	]);
 
-  try {
-    const response = await quickReplyService.updateQuickReply(id, item);
-    return applyTransform(response.data, [snakeToCamel()]);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+	try {
+		const response = await getQuickRepliesService().updateQuickReply(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
-const deleteQuickReply= async ({ id }) => {
-  try {
-    const response = await quickReplyService.deleteQuickReply(id);
-    return applyTransform(response.data, []);
-  } catch (err) {
-    throw applyTransform(err, [notify]);
-  }
+const deleteQuickReply = async ({ id }) => {
+	try {
+		const response = await getQuickRepliesService().deleteQuickReply(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
 };
 
 const getLookup = (params) =>
-  getQuickRepliesList({
-    ...params,
-    fields: params.fields || ['id', 'name'],
-  });
+	getQuickRepliesList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
 
-const QuickRepliesApi = {
-  getList: getQuickRepliesList,
-  get: getQuickReply,
-  add: addQuickReply,
-  update: updateQuickReply,
-  delete: deleteQuickReply,
-  getLookup,
-}
-export default QuickRepliesApi;
+export const QuickRepliesAPI = {
+	getList: getQuickRepliesList,
+	get: getQuickReply,
+	add: addQuickReply,
+	update: updateQuickReply,
+	delete: deleteQuickReply,
+	getLookup,
+};