@webitel/ui-sdk 24.4.19 → 24.4.21

package/src/api/clients/chatGateways/chatGateways.js

@@ -0,0 +1,309 @@
+import deepCopy from 'deep-copy';
+import deepmerge from 'deepmerge';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../defaults';
+import ChatGatewayProvider from '../../../enums/ChatGatewayProvider/ChatGatewayProvider.enum';
+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')
+  ? 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.js

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

@@ -0,0 +1,73 @@
+import ChatGatewayProvider from '../../../../enums/ChatGatewayProvider/ChatGatewayProvider.enum';
+import WebchatAlternativeChannel from '../enums/WebchatAlternativeChannel.enum';
+import defaultChatGateway from '../defaults/defaultChatGateway';
+
+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.js

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

@@ -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;
+};

package/src/api/clients/communications/communications.js

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