@webitel/api-services 0.0.24 → 0.0.25

package/src/api/clients/caseStatuses/caseStatuses.ts

@@ -0,0 +1,119 @@
+import { StatusesApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const statusesService = new StatusesApiFactory(configuration, '', instance);
+
+const fieldsToSend = ['name', 'description'];
+
+const getStatusesList = 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 statusesService.listStatuses(
+      page,
+      size,
+      fields,
+      sort,
+      id,
+      q,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, []),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getStatus = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    return item.status;
+  };
+
+  try {
+    const response = await statusesService.locateStatus(id, fieldsToSend);
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addStatus = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await statusesService.createStatus(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateStatus = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await statusesService.updateStatus(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteStatus = async ({ id }) => {
+  try {
+    const response = await statusesService.deleteStatus(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getStatusesLookup = async (params) =>
+  getStatusesList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const CaseStatusesApi = {
+  getList: getStatusesList,
+  get: getStatus,
+  update: updateStatus,
+  getLookup: getStatusesLookup,
+  delete: deleteStatus,
+  add: addStatus,
+};
+
+export default CaseStatusesApi;

package/src/api/clients/catalog/catalog.ts

@@ -0,0 +1,44 @@
+import { CatalogApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  notify,
+  snakeToCamel,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const catalogService = new CatalogApiFactory(configuration, '', instance);
+
+const getChatMessagesList = async ({ chatId }) => {
+  const mergeMessagesData = ({ messages, peers }) => {
+    if (!messages) return [];
+    return messages.map(({ from, ...message }) => {
+      return {
+        ...message,
+        peer: peers[from.id - 1],
+      };
+    });
+  };
+
+  try {
+    const response = await catalogService.getHistory(chatId);
+    const { messages, peers } = applyTransform(response.data, [snakeToCamel()]);
+    return {
+      items: applyTransform({ messages, peers }, [mergeMessagesData]),
+      peers,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const CatalogAPI = {
+  getChatMessagesList,
+};
+
+export default CatalogAPI;

package/src/api/clients/chatGateways/chatGateways.ts

@@ -0,0 +1,302 @@
+import deepCopy from 'deep-copy';
+import deepmerge from 'deepmerge';
+
+import ChatGatewayProvider from '../../../enums/ChatGatewayProvider/ChatGatewayProvider.enum';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+import webChatGateway from './defaults/webChatGateway';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/chat/bots';
+const fieldsToSend = [
+  'name',
+  'uri',
+  'flow',
+  'enabled',
+  'provider',
+  'metadata',
+  'updates',
+];
+
+const convertWebchatSeconds = (num) => `${num}s`;
+
+const parseTimeoutSeconds = (item) =>
+  item.includes('s') ? Number.parseInt(item.replace('/s', '/'), 10) : +item;
+
+const webchatRequestConverter = (data) => {
+  const copy = deepCopy(data);
+  if (data.metadata.readTimeout) {
+    copy.metadata.readTimeout = convertWebchatSeconds(
+      data.metadata.readTimeout,
+    );
+  }
+  if (data.metadata.writeTimeout) {
+    copy.metadata.writeTimeout = convertWebchatSeconds(
+      data.metadata.writeTimeout,
+    );
+  }
+  if (data.metadata.handshakeTimeout) {
+    copy.metadata.handshakeTimeout = convertWebchatSeconds(
+      data.metadata.handshakeTimeout,
+    );
+  }
+  if (data.metadata.allowOrigin) {
+    copy.metadata.allowOrigin = data.metadata.allowOrigin.join();
+  }
+
+  copy.metadata.view = JSON.stringify(data.metadata.view);
+  copy.metadata.chat = JSON.stringify(data.metadata.chat);
+  copy.metadata.appointment = JSON.stringify(data.metadata.appointment);
+  copy.metadata.alternativeChannels = JSON.stringify(
+    data.metadata.alternativeChannels,
+  );
+  copy.metadata.call = JSON.stringify(data.metadata.call);
+
+  if (copy.metadata.captcha.enabled) {
+    copy.metadata.captcha = JSON.stringify(data.metadata.captcha);
+  } else {
+    delete copy.metadata.captcha;
+  }
+  copy.metadata._btnCodeDirty = data.metadata._btnCodeDirty.toString();
+  return copy;
+};
+
+const messengerRequestConverter = (data) => {
+  const copy = deepCopy(data);
+  copy.metadata.instagramComments = data.metadata.instagramComments.toString();
+  copy.metadata.instagramMentions = data.metadata.instagramMentions.toString();
+  return copy;
+};
+
+const viberRequestConverter = (item) => {
+  const copy = deepCopy(item);
+  copy.metadata['btn.back.color'] = item.metadata.btnBackColor;
+  delete copy.metadata.btnBackColor;
+  copy.metadata['btn.font.color'] = item.metadata.btnFontColor;
+  delete copy.metadata.btnFontColor;
+  return copy;
+};
+
+const webChatResponseConverter = (data) => {
+  const copy = deepCopy(data);
+  copy.metadata.allowOrigin = data.metadata.allowOrigin
+    ? data.metadata.allowOrigin.split(',')
+    : [];
+  if (data.metadata.readTimeout) {
+    copy.metadata.readTimeout = parseTimeoutSeconds(data.metadata.readTimeout);
+  }
+  if (data.metadata.writeTimeout) {
+    copy.metadata.writeTimeout = parseTimeoutSeconds(
+      data.metadata.writeTimeout,
+    );
+  }
+  if (data.metadata.handshakeTimeout) {
+    copy.metadata.handshakeTimeout = parseTimeoutSeconds(
+      data.metadata.handshakeTimeout,
+    );
+  }
+  if (data.metadata.view) {
+    copy.metadata.view = JSON.parse(data.metadata.view);
+  }
+  if (data.metadata.chat) {
+    copy.metadata.chat = JSON.parse(data.metadata.chat);
+  }
+  if (data.metadata.appointment) {
+    copy.metadata.appointment = JSON.parse(data.metadata.appointment);
+  }
+  if (data.metadata.alternativeChannels) {
+    copy.metadata.alternativeChannels = JSON.parse(
+      data.metadata.alternativeChannels,
+    );
+  }
+  if (data.metadata.call) {
+    copy.metadata.call = JSON.parse(data.metadata.call);
+  }
+  if (data.metadata.captcha) {
+    copy.metadata.captcha = JSON.parse(data.metadata.captcha);
+  }
+  copy.metadata._btnCodeDirty = data.metadata._btnCodeDirty === 'true';
+
+  return deepmerge(webChatGateway(), copy);
+};
+
+const messengerResponseConverter = (item) => {
+  const copy = deepCopy(item);
+  copy.metadata.instagramComments = item.metadata.instagramComments === 'true';
+  copy.metadata.instagramMentions = item.metadata.instagramMentions === 'true';
+  return copy;
+};
+
+const viberResponseConverter = (item) => {
+  const copy = deepCopy(item);
+  if (item.metadata['btn.back.color'])
+    copy.metadata.btnBackColor = item.metadata['btn.back.color'];
+  if (item.metadata['btn.font.color'])
+    copy.metadata.btnFontColor = item.metadata['btn.font.color'];
+  return copy;
+};
+
+const preRequestHandler = (item) => {
+  switch (item.provider) {
+    case ChatGatewayProvider.WEBCHAT:
+      return webchatRequestConverter(item);
+    case ChatGatewayProvider.MESSENGER:
+      return messengerRequestConverter(item);
+    case ChatGatewayProvider.VIBER:
+      return viberRequestConverter(item);
+    default:
+      return item;
+  }
+};
+
+const getChatGatewayList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const defaultObject = {
+    // default object prototype, to merge response with it to get all fields
+    enabled: false,
+    name: '',
+    uri: '',
+    flow: {},
+    provider: '',
+    metadata: {},
+    updates: {
+      title: '',
+      close: '',
+      join: '',
+      left: '',
+    },
+  };
+
+  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 getChatGateway = async ({ itemId: id }) => {
+  const itemResponseHandler = (response) => {
+    switch (response.provider) {
+      case ChatGatewayProvider.WEBCHAT:
+        return webChatResponseConverter(response);
+      case ChatGatewayProvider.MESSENGER:
+        return messengerResponseConverter(response);
+      case ChatGatewayProvider.VIBER:
+        return viberResponseConverter(response);
+      default:
+        return 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 addChatGateway = 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 updateChatGateway = 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 patchChatGateway = 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 deleteChatGateway = async ({ id }) => {
+  const url = `${baseUrl}/${id}`;
+  try {
+    const response = await instance.delete(url);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getLookup = (params) =>
+  getChatGatewayList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const ChatGatewaysAPI = {
+  getList: getChatGatewayList,
+  get: getChatGateway,
+  add: addChatGateway,
+  patch: patchChatGateway,
+  update: updateChatGateway,
+  delete: deleteChatGateway,
+  getLookup,
+};
+
+export default ChatGatewaysAPI;

package/src/api/clients/chatGateways/defaults/defaultChatGateway.ts

@@ -0,0 +1,18 @@
+import generateUri from '../scripts/generateUri';
+
+const defaultChatGateway = () => ({
+  name: '',
+  uri: generateUri(),
+  flow: {},
+  enabled: false,
+  provider: '',
+  metadata: {},
+  updates: {
+    title: '',
+    close: '',
+    join: '',
+    left: '',
+  },
+});
+
+export default defaultChatGateway;

package/src/api/clients/chatGateways/defaults/webChatGateway.ts

@@ -0,0 +1,72 @@
+import ChatGatewayProvider from '../../../../enums/ChatGatewayProvider/ChatGatewayProvider.enum';
+import defaultChatGateway from '../defaults/defaultChatGateway';
+import WebchatAlternativeChannel from '../enums/WebchatAlternativeChannel.enum';
+
+const webChatGateway = (_btnCodeDirty = false) => ({
+  ...defaultChatGateway(),
+  provider: ChatGatewayProvider.WEBCHAT,
+  metadata: {
+    // start: these fields related to chat functionality but should be in metadata for backend
+    allowOrigin: [],
+    readTimeout: '30',
+    writeTimeout: '1',
+    handshakeTimeout: '10',
+    mediaMaxSize: `${10 * 1024 * 1024}`, // 10mb
+    // end
+
+    _btnCodeDirty, // inner flag, if true, btn "copy code" is highlighted
+    view: {
+      borderRadiusStyle: '',
+      lang: 'en',
+      btnOpacity: '',
+      logoUrl: '',
+      accentColor: '',
+      position: '',
+    },
+    captcha: {
+      enabled: false,
+      sitekey: '',
+      secret: '',
+      threshold: 0.5,
+      showFlag: false,
+    },
+    chat: {
+      enabled: true,
+      timeoutIsActive: false,
+      openTimeout: '',
+      url: '',
+    },
+    appointment: {
+      enabled: false,
+      url: '',
+      queue: {},
+      communicationType: {},
+      duration: '30m',
+      days: 3,
+      availableAgents: 1,
+      successTitle: '',
+      successSubtitle: '',
+      showDefaultHeading: true,
+      showEmailField: false,
+      showMessageField: false,
+    },
+    call: {
+      enabled: false,
+      url: '',
+      flow: {},
+      id: '',
+    },
+    alternativeChannels: Object.values(WebchatAlternativeChannel).reduce(
+      (channels, channel) => ({
+        ...channels,
+        [channel]: {
+          url: '',
+          enabled: false,
+        },
+      }),
+      {},
+    ),
+  },
+});
+
+export default webChatGateway;

package/src/api/clients/chatGateways/enums/WebchatAlternativeChannel.enum.ts

@@ -0,0 +1,14 @@
+/* Difference between MessangerType enum and WebchatAlternativeChannel:
+ * MessangerType - backend fields naming, provider
+ * WebchatAlternativeChannel - front-end only "simple" channel naming
+ * */
+
+const WebchatAlternativeChannel = Object.freeze({
+  VIBER: 'viber',
+  WHATSAPP: 'whatsapp',
+  TELEGRAM: 'telegram',
+  MESSENGER: 'messenger',
+  EMAIL: 'email',
+});
+
+export default WebchatAlternativeChannel;

package/src/api/clients/chatGateways/scripts/generateUri.ts

@@ -0,0 +1,9 @@
+export default () => {
+  const length = 31;
+  const charset = 'abcdefghijklmnopqrstuvwxyz';
+  let value = '/';
+  for (let i = 0; i < length; i += 1) {
+    value += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return value;
+};