@webitel/api-services 0.0.23 → 0.0.25

package/src/api/clients/gateways/defaults/trunkingGateway.ts

@@ -0,0 +1,16 @@
+import defaultGateway from './defaultGateway';
+
+const trunkingGateway = () => ({
+  ...defaultGateway(),
+  register: false,
+  host: '',
+  ipacl: [
+    // {
+    //   ip: '',
+    //   proto: 'any',
+    //   port: null,
+    // },
+  ],
+});
+
+export default trunkingGateway;

package/src/api/clients/gateways/gateways.ts

@@ -0,0 +1,175 @@
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+import registerGateway from './defaults/registerGateway';
+import trunkingGateway from './defaults/trunkingGateway';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/sip/gateways';
+
+const getGatewayList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id', 'name'];
+
+  const defaultObject = {
+    name: '',
+    proxy: '',
+    enable: false,
+  };
+
+  const url = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    starToSearch('name'),
+    (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: applyTransform(items, [mergeEach(defaultObject)]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getGateway = async ({ itemId: id }) => {
+  const coerceTrunkingResponse = (response) => {
+    const defaultIPacl = {
+      ip: '',
+      proto: 'any',
+      port: null,
+    };
+
+    const result = { ...trunkingGateway(), ...response };
+    result.ipacl = result.ipacl.map((acl) => ({ ...defaultIPacl, ...acl }));
+    return result;
+  };
+
+  const coerceRegisterResponse = (response) => {
+    const result = { ...registerGateway(), ...response };
+    return result;
+  };
+
+  const itemResponseHandler = (response) => {
+    if (response.register) return coerceRegisterResponse(response);
+    return coerceTrunkingResponse(response);
+  };
+
+  const url = `${baseUrl}/${id}`;
+
+  try {
+    const response = await instance.get(url);
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const fieldsToSend = [
+  'name',
+  'proxy',
+  'id',
+  'host',
+  'ipacl',
+  'account',
+  'username',
+  'expires',
+  'account',
+  'registrar',
+  'name',
+  'register',
+  'password',
+  'schema',
+  'usage',
+  'enable',
+];
+
+const addGateway = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await instance.post(baseUrl, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+const updateGateway = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    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 patchGateway = async ({ changes, id }) => {
+  const body = applyTransform(changes, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  const url = `${baseUrl}/${id}`;
+  try {
+    const response = await instance.patch(url, body);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteGateway = async ({ id }) => {
+  const url = `${baseUrl}/${id}`;
+  try {
+    const response = await instance.delete(url);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getGatewaysLookup = (params) =>
+  getGatewayList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const GatewaysAPI = {
+  getList: getGatewayList,
+  get: getGateway,
+  add: addGateway,
+  patch: patchGateway,
+  update: updateGateway,
+  delete: deleteGateway,
+  getLookup: getGatewaysLookup,
+};
+
+export default GatewaysAPI;

package/src/api/clients/index.ts

@@ -0,0 +1,68 @@
+import agentChats from './agents/agentChats';
+import agents from './agents/agents';
+import buckets from './buckets/buckets';
+import calendars from './calendars/calendars';
+import caseCloseReasonGroups from './caseCloseReasonGroups/caseCloseReasonGroups';
+import caseCloseReasons from './caseCloseReasons/caseCloseReasons';
+import casePriorities from './casePriorities/casePriorities';
+import caseServiceCatalogs from './caseServiceCatalogs/serviceCatalogs';
+import caseSources from './caseSources/caseSources';
+import caseStatusConditions from './caseStatusConditions/caseStatusConditions';
+import caseStatuses from './caseStatuses/caseStatuses';
+import catalog from './catalog/catalog';
+import chatGateways from './chatGateways/chatGateways';
+import communications from './communications/communications';
+import configurations from './configurations/configurations';
+import contactGroups from './contactGroups/contactGroups';
+import flows from './flows/flow';
+import gateways from './gateways/gateways';
+import labels from './labels/labels';
+import lists from './lists/blacklists';
+import media from './media/media';
+import object from './object/object';
+import queues from './queues/queues';
+import roles from './roles/roles';
+import skills from './skills/skills';
+import slas from './slas/slas';
+import teams from './teams/teams';
+import users from './users/users';
+import sysTypes from './wtTypes/sysTypes/sysTypes';
+import typeExtensions from './wtTypes/typeExtensions/typeExtensions';
+import { contactChatMessagesHistory, contacts } from './сontacts/index';
+import quickReplies from './quickReplies/quickReplies';
+
+export {
+  agentChats,
+  agents,
+  buckets,
+  calendars,
+  caseCloseReasonGroups,
+  caseCloseReasons,
+  casePriorities,
+  caseServiceCatalogs,
+  caseSources,
+  caseStatusConditions,
+  caseStatuses,
+  catalog,
+  chatGateways,
+  communications,
+  configurations,
+  contactChatMessagesHistory,
+  contactGroups,
+  contacts,
+  flows,
+  gateways,
+  labels,
+  lists,
+  media,
+  object,
+  queues,
+  quickReplies,
+  roles,
+  skills,
+  slas,
+  sysTypes,
+  teams,
+  typeExtensions,
+  users,
+};

package/src/api/clients/labels/labels.ts

@@ -0,0 +1,56 @@
+import {
+  getDefaultGetParams,
+  getDefaultInstance, getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+import { LabelsApiFactory } from 'webitel-sdk';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const service = new LabelsApiFactory(configuration, '', instance);
+
+const getList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'search', 'sort', 'fields', 'id'];
+  const {
+    page,
+    size,
+    search,
+  } = applyTransform(params, [
+    sanitize(fieldsToSend),
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await service.getLabels(page, size, search);
+    const { labels, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge({ labels: [], next: false }),
+    ]);
+    return {
+      items: labels,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getLabelsLookup = (params) =>
+  getList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+export default {
+  getList,
+  getLookup: getLabelsLookup,
+};

package/src/api/clients/lists/blacklists.ts

@@ -0,0 +1,118 @@
+import { ListServiceApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const listService = new ListServiceApiFactory(configuration, '', instance);
+
+const getBlacklistList = async (params) => {
+  const defaultObject = {
+    name: '',
+    count: 0,
+  };
+
+  const { page, size, search, sort, fields, id } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    camelToSnake(),
+  ]);
+
+  try {
+    const response = await listService.searchList(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+      id,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, [mergeEach(defaultObject)]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getBlacklist = async ({ itemId: id }) => {
+  try {
+    const response = await listService.readList(id);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const fieldsToSend = ['name', 'description'];
+
+const addBlacklist = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await listService.createList(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateBlacklist = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await listService.updateList(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteBlacklist = async ({ id }) => {
+  try {
+    const response = await listService.deleteList(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+const getBlacklistsLookup = (params) =>
+  getBlacklistList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const BlacklistsAPI = {
+  getList: getBlacklistList,
+  get: getBlacklist,
+  add: addBlacklist,
+  update: updateBlacklist,
+  delete: deleteBlacklist,
+  getLookup: getBlacklistsLookup,
+};
+
+export default BlacklistsAPI;

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

@@ -0,0 +1,120 @@
+import axios from 'axios';
+import { MediaFileServiceApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  merge,
+  notify,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const mediaService = new MediaFileServiceApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const token = localStorage.getItem('access-token');
+const baseUrl = import.meta.env.VITE_API_URL;
+
+const getMediaList = async (params) => {
+  const { page, size, search, sort, fields, id } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await mediaService.searchMediaFile(
+      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 getMedia = async ({ itemId }) => {
+  const url = `${baseUrl}/storage/media/${itemId}/stream?access_token=${token}`;
+  try {
+    return await instance.get(url);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+export const downloadMedia = async (id) => {
+  const url = `${baseUrl}/storage/media/${id}/download?access_token=${token}`;
+  try {
+    return await instance.get(url);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addMediaInstance = axios.create({
+  headers: {
+    'content-type': 'multipart/form-data',
+  },
+});
+
+const addMedia = async (params) => {
+  const url = `${baseUrl}/storage/media?access_token=${token}`;
+
+  const formData = new FormData();
+  formData.append('file', params.itemInstance);
+  try {
+    const response = await addMediaInstance.post(url, formData);
+    applyTransform(response, [
+      notify(() => ({ type: 'success', text: 'Successfully added' })),
+    ]);
+    return response;
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteMedia = async ({ id }) => {
+  try {
+    const response = await mediaService.deleteMediaFile(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getMediaLookup = (params) =>
+  getMediaList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const MediaAPI = {
+  getList: getMediaList,
+  get: getMedia,
+  add: addMedia,
+  delete: deleteMedia,
+  getLookup: getMediaLookup,
+};
+
+export default MediaAPI;

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

@@ -0,0 +1,114 @@
+import { TypesApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const typeService = new TypesApiFactory(configuration, '', instance);
+
+const getObjectList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const { page, size, fields, sort, id, q } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await typeService.search(
+      q,
+      id,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      size,
+      page,
+      sort,
+      fields,
+    );
+    const { data, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+
+    const itemResponseHandler = (items) =>
+      (items || []).map((item) => ({
+        ...item,
+        id: item.repo,
+      }));
+
+    return {
+      items: applyTransform(data, [snakeToCamel(), itemResponseHandler]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getObjectLookupList = async ({ ...params }) => {
+  const fieldsToSend = [
+    'page',
+    'size',
+    'q',
+    'sort',
+    'extensions',
+    'fields',
+    'id',
+  ];
+
+  const url = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    (params) => ({ ...params, q: params.search, extensions: false }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+    generateUrl('types'),
+  ]);
+  try {
+    const response = await instance.get(url);
+    const { data, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+
+    return {
+      items: data ?? [],
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getObjectLookup = async (params) =>
+  getObjectLookupList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const ObjectsApi = {
+  getList: getObjectList,
+  getLookup: getObjectLookup,
+};
+
+export default ObjectsApi;

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

@@ -0,0 +1,14 @@
+import deepmerge from 'deepmerge';
+
+const processing = (processing = {}) =>
+  deepmerge(
+    {
+      enabled: false,
+      formSchema: {},
+      sec: 30,
+      renewalSec: 15,
+    },
+    processing,
+  );
+
+export default processing;