@webitel/ui-sdk 24.4.19 → 24.4.21

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

@@ -0,0 +1,256 @@
+import {
+  EngineRoutingSchemaType,
+  RoutingSchemaServiceApiFactory,
+} from 'webitel-sdk';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+
+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.js

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

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

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

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

@@ -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.js

@@ -0,0 +1,204 @@
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../defaults';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+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'];
+
+  const defaultObject = {
+    name: '',
+    proxy: '',
+    enable: false,
+  };
+
+  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: 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.js

@@ -0,0 +1,27 @@
+import agents from './agents/agents';
+import buckets from './buckets/buckets';
+import calendars from './calendars/calendars';
+import chatGateways from './chatGateways/chatGateways';
+import communications from './communications/communications';
+import flows from './flows/flow';
+import gateways from './gateways/gateways';
+import lists from './lists/blacklists';
+import media from './media/media';
+import queues from './queues/queues';
+import roles from './roles/roles';
+import users from './users/users';
+
+export {
+  agents,
+  buckets,
+  calendars,
+  chatGateways,
+  communications,
+  flows,
+  gateways,
+  lists,
+  media,
+  queues,
+  roles,
+  users,
+};

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

@@ -0,0 +1,144 @@
+import { ListServiceApiFactory } from 'webitel-sdk';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults';
+import applyTransform, {
+  camelToSnake,
+  merge, mergeEach,
+  notify, sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+
+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;