@webitel/api-services 0.0.23 → 0.0.25

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

@@ -0,0 +1,238 @@
+import deepCopy from 'deep-copy';
+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';
+import processing from './defaults/processing';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const queueService = new 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',
+];
+
+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 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 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 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 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 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 deleteQueue = async ({ id }) => {
+  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'],
+  });
+
+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 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

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

package/src/api/clients/roles/roles.ts

@@ -0,0 +1,202 @@
+import deepCopy from 'deep-copy';
+
+import ApplicationsAccess from '../../../modules/Userinfo/classes/ApplicationsAccess';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/roles';
+const fieldsToSend = ['name', 'description', 'permissions', 'metadata'];
+
+const preRequestHandler = (item) => {
+  const copy = deepCopy(item);
+  copy.metadata.access = ApplicationsAccess.minify(copy.metadata.access);
+  return copy;
+};
+
+const getRoleList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'ids'];
+
+  const url = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    (params) => {
+      params.ids = params.ids || params.id; // accept either ids or id as param
+      return params;
+    },
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+    generateUrl(baseUrl),
+  ]);
+  try {
+    const response = await instance.get(url);
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getRole = async ({ itemId: id }) => {
+  const defaultObject = {
+    name: '',
+    description: '',
+    permissions: [],
+    metadata: {},
+  };
+
+  const itemResponseHandler = (response) => {
+    const copy = deepCopy(response);
+    copy.metadata.access = new ApplicationsAccess({
+      access: copy.metadata.access,
+    }).getAccess();
+    return copy;
+  };
+
+  const url = `${baseUrl}/${id}?fields=metadata&fields=permissions&fields=name&fields=description`;
+
+  try {
+    const response = await instance.get(url);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      merge(defaultObject),
+      itemResponseHandler,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getExtendedRoles = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const url = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+    generateUrl(baseUrl),
+  ]);
+  try {
+    const response = await instance.get(url);
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addRole = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await instance.post(baseUrl, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateRole = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+
+  const url = `${baseUrl}/${id}`;
+  try {
+    const response = await instance.put(url, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteRole = async ({ id }) => {
+  const url = `${baseUrl}/${id}`;
+  try {
+    const response = await instance.delete(url);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getRolesLookup = (params) =>
+  getRoleList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const PERMISSIONS_LIST_URL = '/permissions';
+
+const getPermissionsOptions = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const url = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+    generateUrl(PERMISSIONS_LIST_URL),
+  ]);
+  try {
+    const response = await instance.get(url);
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const RolesAPI = {
+  getList: getRoleList,
+  get: getRole,
+  add: addRole,
+  update: updateRole,
+  delete: deleteRole,
+  getLookup: getRolesLookup,
+
+  getExtendedRoles,
+  getPermissionsOptions,
+};
+
+export default RolesAPI;

package/src/api/clients/skills/skills.ts

@@ -0,0 +1,112 @@
+import { SkillServiceApiFactory } 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 skillService = new SkillServiceApiFactory(configuration, '', instance);
+
+const getSkillsList = async (params) => {
+  const { page, size, search, sort, fields, id } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await skillService.searchSkill(
+      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 getSkill = async ({ itemId: id }) => {
+  try {
+    const response = await skillService.readSkill(id);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const fieldsToSend = ['name', 'description'];
+
+const addSkill = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await skillService.createSkill(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateSkill = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await skillService.updateSkill(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteSkill = async ({ id }) => {
+  try {
+    const response = await skillService.deleteSkill(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getSkillsLookup = (params) =>
+  getSkillsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const SkillsAPI = {
+  getList: getSkillsList,
+  get: getSkill,
+  add: addSkill,
+  update: updateSkill,
+  delete: deleteSkill,
+  getLookup: getSkillsLookup,
+};
+
+export default SkillsAPI;