@webitel/api-services 0.0.23 → 0.0.25

package/src/api/clients/communications/communications.ts

@@ -0,0 +1,141 @@
+import { CommunicationTypeServiceApiFactory } 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 communicationService = new CommunicationTypeServiceApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const getCommunicationsList = async (params) => {
+  const defaultObject = {
+    default: false,
+  };
+
+  const { page, size, search, sort, fields, id } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await communicationService.searchCommunicationType(
+      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 getCommunication = async ({ itemId: id }) => {
+  try {
+    const response = await communicationService.readCommunicationType(id);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const fieldsToSend = ['code', 'name', 'description', 'channel', 'default'];
+
+const addCommunication = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await communicationService.createCommunicationType(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const patchCommunication = async ({ changes, id }) => {
+  const body = applyTransform(changes, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await communicationService.patchCommunicationType(
+      id,
+      body,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateCommunication = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await communicationService.updateCommunicationType(
+      id,
+      item,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteCommunication = async ({ id }) => {
+  try {
+    const response = await communicationService.deleteCommunicationType(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getCommunicationsLookup = (params) =>
+  getCommunicationsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const CommunicationsAPI = {
+  getList: getCommunicationsList,
+  get: getCommunication,
+  add: addCommunication,
+  patch: patchCommunication,
+  update: updateCommunication,
+  delete: deleteCommunication,
+  getLookup: getCommunicationsLookup,
+};
+
+export default CommunicationsAPI;

package/src/api/clients/configurations/configurations.ts

@@ -0,0 +1,144 @@
+import { SystemSettingServiceApiFactory } 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 configurationService = new SystemSettingServiceApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const getList = async (params) => {
+  const { page, size, search, sort, fields, name } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await configurationService.searchSystemSetting(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+      name,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const get = async ({ itemId: id }) => {
+  try {
+    const response = await configurationService.readSystemSetting(id);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const fieldsToSend = ['id', 'name', 'value'];
+
+const add = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await configurationService.createSystemSetting(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const update = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await configurationService.updateSystemSetting(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getLookup = (params) =>
+  getList({
+    ...params,
+    fields: params.fields || ['name'],
+  });
+
+const deleteItem = async ({ id }) => {
+  try {
+    const response = await configurationService.deleteSystemSetting(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getObjectsList = async (params) => {
+  const { page, size, search, sort, fields } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await configurationService.searchAvailableSystemSetting(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const ConfigurationsAPI = {
+  getList,
+  get,
+  add,
+  update,
+  delete: deleteItem,
+  getLookup,
+  getObjectsList,
+};
+
+export default ConfigurationsAPI;

package/src/api/clients/contactGroups/contactGroups.ts

@@ -0,0 +1,187 @@
+import { GroupsApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+import { generatePermissionsApi } from '../_shared/generatePermissionsApi';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const contactGroupsService = new GroupsApiFactory(configuration, '', instance);
+
+const baseUrl = '/contacts/groups';
+
+const fieldsToSend = [
+  'name',
+  'description',
+  'enabled',
+  'type',
+  'default_group',
+];
+
+const getContactGroupsList = async (params) => {
+  const fieldsToSend = [
+    'page',
+    'size',
+    'q',
+    'sort',
+    'fields',
+    'type',
+    'enabled',
+    'id',
+  ];
+  const defaultObject = {
+    enabled: false,
+  };
+
+  const { page, size, fields, sort, id, q, name, type, enabled } =
+    applyTransform(params, [
+      merge(getDefaultGetParams()),
+      (params) => ({ ...params, q: params.search }),
+      sanitize(fieldsToSend),
+      camelToSnake(),
+    ]);
+
+  try {
+    const response = await contactGroupsService.listGroups(
+      page,
+      size,
+      fields,
+      sort,
+      id,
+      q,
+      name,
+      type,
+      enabled,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, [mergeEach(defaultObject)]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getContactGroup = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => item.group;
+
+  try {
+    const response = await contactGroupsService.locateGroup(id, fieldsToSend);
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addStaticContactGroup = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await contactGroupsService.createGroup(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addContactsToGroups = async ({ contactIds, groupIds }) => {
+  try {
+    const response = await contactGroupsService.addContactsToGroups({
+      groupIds,
+      contactIds,
+    });
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const removeContactsFromGroup = async ({ id, contactIds }) => {
+  try {
+    const response = await contactGroupsService.removeContactsFromGroup(
+      id,
+      contactIds,
+    );
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateStaticContactGroup = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await contactGroupsService.updateGroup(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const patchStaticContactGroup = async ({ id, changes }) => {
+  const item = applyTransform(changes, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await contactGroupsService.updateGroup2(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteStaticContactGroup = async ({ id }) => {
+  try {
+    const response = await contactGroupsService.deleteGroup(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getLookup = (params) =>
+  getContactGroupsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const ContactGroupsAPI = {
+  getList: getContactGroupsList,
+  get: getContactGroup,
+  add: addStaticContactGroup,
+  update: updateStaticContactGroup,
+  patch: patchStaticContactGroup,
+  delete: deleteStaticContactGroup,
+  getLookup,
+  addContactsToGroups,
+  removeContactsFromGroup,
+
+  ...generatePermissionsApi(baseUrl),
+};
+
+export default ContactGroupsAPI;

package/src/api/clients/flows/flow.ts

@@ -0,0 +1,225 @@
+import {
+  EngineRoutingSchemaType,
+  RoutingSchemaServiceApiFactory,
+} 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 flowService = new RoutingSchemaServiceApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+/*
+CONVERT "SCHEMA" FIELD TO JSON TO PREVENT ITS CHANGE
+BY CAMEL-SNAKE TRANSFORMERS
+ */
+const doNotConvertKeys = ['schema'];
+
+const fieldsToSend = ['name', 'schema', 'type', 'payload', 'editor', 'tags'];
+
+const getFlowList = async (params) => {
+  const defaultObject = {
+    type: EngineRoutingSchemaType.Default,
+    editor: false,
+  };
+
+  const paramsCopy = {
+    ...params,
+  };
+
+  if (paramsCopy.type) {
+    const _type = Array.isArray(paramsCopy.type)
+      ? paramsCopy.type
+      : [paramsCopy.type];
+    if (!paramsCopy.type.includes(EngineRoutingSchemaType.Default)) {
+      _type.push(EngineRoutingSchemaType.Default);
+    }
+    paramsCopy.type = _type;
+  }
+
+  const { page, size, search, sort, fields, id, name, type, tags } =
+    applyTransform(paramsCopy, [
+      merge(getDefaultGetParams()),
+      starToSearch('search'),
+      camelToSnake(doNotConvertKeys),
+    ]);
+
+  try {
+    const response = await flowService.searchRoutingSchema(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+      id,
+      name,
+      type,
+      undefined,
+      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 getFlow = async ({ itemId: id }) => {
+  const defaultObject = {
+    tags: [],
+    editor: false,
+    type: EngineRoutingSchemaType.Default,
+  };
+
+  const itemResponseHandler = (item) => ({
+    ...item,
+    schema: JSON.stringify(item.schema, null, 4),
+  });
+
+  try {
+    const response = await flowService.readRoutingSchema(id);
+    return applyTransform(response.data, [
+      ({ payload, schema, ...rest }) => ({
+        payload,
+        schema,
+        ...snakeToCamel(doNotConvertKeys)(rest),
+      }),
+      merge(defaultObject),
+      itemResponseHandler,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const preRequestHandler = (item) => ({
+  ...item,
+  schema:
+    typeof item.schema === 'string' ? JSON.parse(item.schema) : item.schema,
+});
+
+const addFlow = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    ({ payload, schema, ...rest }) => ({
+      payload,
+      schema,
+      ...camelToSnake(doNotConvertKeys)(rest),
+    }),
+  ]);
+  try {
+    const response = await flowService.createRoutingSchema(item);
+    return applyTransform(response.data, [
+      ({ payload, schema, ...rest }) => ({
+        payload,
+        schema,
+        ...snakeToCamel(doNotConvertKeys)(rest),
+      }),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+const updateFlow = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    ({ payload, schema, ...rest }) => ({
+      payload,
+      schema,
+      ...camelToSnake(doNotConvertKeys)(rest),
+    }),
+  ]);
+  try {
+    const response = await flowService.updateRoutingSchema(id, item);
+    return applyTransform(response.data, [
+      ({ payload, schema, ...rest }) => ({
+        payload,
+        schema,
+        ...snakeToCamel(doNotConvertKeys)(rest),
+      }),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteFlow = async ({ id }) => {
+  try {
+    const response = await flowService.deleteRoutingSchema(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getFlowsLookup = (params) =>
+  getFlowList({
+    ...params,
+    fields: params.fields || ['id', 'name', 'type'],
+  });
+
+const getFlowTags = async (params) => {
+  const { page, size, search, sort, fields, ids } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch(),
+    camelToSnake(doNotConvertKeys),
+  ]);
+  try {
+    const response = await flowService.searchRoutingSchemaTags(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+      ids,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(doNotConvertKeys),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const FlowsAPI = {
+  getList: getFlowList,
+  get: getFlow,
+  add: addFlow,
+  update: updateFlow,
+  delete: deleteFlow,
+  getLookup: getFlowsLookup,
+  getFlowTags,
+};
+
+export default FlowsAPI;

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

@@ -0,0 +1,9 @@
+const defaultGateway = () => ({
+  name: '',
+  usage: '',
+  proxy: '',
+  schema: {},
+  enable: true,
+});
+
+export default defaultGateway;

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

@@ -0,0 +1,12 @@
+import defaultGateway from './defaultGateway';
+
+const registerGateway = () => ({
+  ...defaultGateway(),
+  register: true,
+  account: '',
+  username: '',
+  expires: 600,
+  password: '',
+});
+
+export default registerGateway;