@webitel/api-services 0.0.23 → 0.0.25

package/src/api/clients//321/201ontacts/contacts.ts

@@ -0,0 +1,339 @@
+import deepCopy from 'deep-copy';
+import { ContactsApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+} from '../../transformers/index';
+import ContactsSearchMode from './enums/ContactsSearchMode';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const contactService = new ContactsApiFactory(configuration, '', instance);
+
+const formatAccessMode = (item) => ({
+  ...item,
+  access: {
+    edit: item.mode.includes('w'),
+    delete: item.mode.includes('d'),
+  },
+});
+
+const getList = async (params) => {
+  const fieldsToSend = [
+    'page',
+    'size',
+    'q',
+    'sort',
+    'fields',
+    'id',
+    'qin',
+    'notIdGroup',
+    'group',
+    'owner',
+    'label',
+    'user',
+  ];
+
+  if (!params.fields) {
+    params.fields = [
+      'id',
+      'etag',
+      'name',
+      'managers',
+      'labels',
+      'about',
+      'variables',
+      'timezones',
+      'phones',
+      'emails',
+      'imclients',
+    ];
+  }
+
+  const listResponseHandler = (items) =>
+    items?.map((item) => ({
+      ...item,
+      name: item.name.commonName,
+      managers: item.managers ? [...item.managers.data] : [],
+      labels: item.labels ? [...item.labels.data] : [],
+      groups: getGroupsFromResponse(item),
+      variables: item.variables ? [...item.variables.data] : [],
+      timezones: item.timezones ? [...item.timezones.data] : [],
+      phones: item.phones ? [...item.phones.data] : [],
+      emails: item.emails ? [...item.emails.data] : [],
+    }));
+
+  let changedParams;
+
+  if (params?.search) {
+    changedParams = { ...params, q: params.search };
+  } else if (params?.q && params?.qin) {
+    changedParams = { ...params };
+  } else {
+    let searchValue = '';
+    let searchKey = '';
+
+    if (params[ContactsSearchMode.NAME]) {
+      searchValue = params[ContactsSearchMode.NAME];
+      searchKey = ContactsSearchMode.NAME;
+    } else if (params[ContactsSearchMode.LABELS]) {
+      searchValue = params[ContactsSearchMode.LABELS];
+      searchKey = ContactsSearchMode.LABELS;
+    } else if (params[ContactsSearchMode.ABOUT]) {
+      searchValue = params[ContactsSearchMode.ABOUT];
+      searchKey = ContactsSearchMode.ABOUT;
+    } else if (params[ContactsSearchMode.VARIABLES]) {
+      searchValue = params[ContactsSearchMode.VARIABLES];
+      searchKey = ContactsSearchMode.VARIABLES;
+    } else if (params[ContactsSearchMode.DESTINATION]) {
+      searchValue = params[ContactsSearchMode.DESTINATION];
+      searchKey = 'emails,phones,imclients{user{name}}';
+    }
+
+    // This code needed for adding starToSearch method to applyTransform while searchKey !== SearchMode.VARIABLES because '*' in variables search mode brokes backend logic.
+    // if (searchKey !== ContactsSearchMode.VARIABLES) {
+    //   transformations.push(starToSearch('q')); WTEL-4265
+    // }
+
+    changedParams = {
+      ...params,
+      q: searchValue || '',
+      qin: searchKey || '',
+    };
+
+    if (params.hasUser != null) {
+      changedParams.user = params.hasUser;
+    }
+
+    if (params.contactGroup) {
+      changedParams.group = [...params.contactGroup.list];
+    }
+    if (params.contactLabel) {
+      changedParams.label = params.contactLabel.map((item) => item.label);
+    }
+    if (params.contactOwner) {
+      changedParams.owner = params.contactOwner;
+    }
+  }
+
+  if (params.parentId) {
+    changedParams.group = [params.parentId];
+  }
+
+  const transformations = [
+    sanitize(fieldsToSend),
+    merge(getDefaultGetParams()),
+    camelToSnake(),
+  ];
+
+  const {
+    page,
+    size,
+    q,
+    sort,
+    fields,
+    id,
+    qin,
+    mode,
+    group_id,
+    group,
+    not_id_group,
+    owner,
+    label,
+    user,
+  } = applyTransform(changedParams, transformations);
+
+  try {
+    const response = await contactService.searchContacts(
+      page,
+      size,
+      q,
+      sort || '+name',
+      ['mode', ...fields],
+      id,
+      qin,
+      mode,
+      not_id_group,
+      group,
+      owner,
+      label,
+      user,
+    );
+
+    const { items, next } = applyTransform(
+      { ...response.data, items: response.data.data || [] },
+      [snakeToCamel(['custom']), merge(getDefaultGetListResponse())],
+    );
+
+    return {
+      items: applyTransform(items, [
+        (items) => items?.map((item) => formatAccessMode(item)),
+        listResponseHandler,
+      ]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const get = async ({ itemId: id }) => {
+  const fields = [
+    'name',
+    'about',
+    'labels',
+    'groups',
+    'etag',
+    'mode',
+    'managers',
+    'timezones',
+    'variables',
+    'phones',
+    'emails',
+    'imclients',
+    'user',
+    'custom',
+  ];
+
+  const defaultObject = {};
+  const itemResponseHandler = (item) => {
+    return {
+      ...item,
+      name: item.name.commonName,
+      labels: item.labels ? [...item.labels.data] : [],
+      groups: getGroupsFromResponse(item),
+      managers: item.managers ? [...item.managers.data] : [],
+      timezones: item.timezones ? [...item.timezones.data] : [],
+      variables: item.variables ? [...item.variables.data] : [],
+      phones: item.phones ? [...item.phones.data] : [],
+      emails: item.emails ? [...item.emails.data] : [],
+    };
+  };
+  try {
+    const response = await contactService.locateContact(id, fields);
+    return applyTransform(response.data, [
+      snakeToCamel(['custom']),
+      merge(defaultObject),
+      itemResponseHandler,
+      formatAccessMode,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const fieldsToSend = [
+  'name',
+  'labels',
+  'about',
+  'managers',
+  'timezones',
+  'groups',
+  'custom',
+];
+
+const sanitizeManagers = (itemInstance) => {
+  // handle many managers and even no managers field cases
+  const managers = (itemInstance.managers || []).filter(
+    ({ user } = {}) => user.id,
+  );
+  return { ...itemInstance, managers };
+};
+
+const sanitizeTimezones = (itemInstance) => {
+  // handle many timezones and even no timezones field cases
+  const timezones = (itemInstance.timezones || []).filter(
+    ({ timezone } = {}) => timezone.id,
+  );
+  return { ...itemInstance, timezones };
+};
+
+const sanitizeGroups = (itemInstance) => {
+  // handle many groups and even no groups field cases
+  const groups = (itemInstance.groups || []).map((item) => ({ group: item }));
+  return { ...itemInstance, groups };
+};
+
+const preRequestHandler = (item) => {
+  const copy = deepCopy(item);
+  copy.name = {
+    commonName: copy.name,
+  };
+  return copy;
+};
+
+const getGroupsFromResponse = (item) => {
+  return item.groups ? [...item.groups.data.map((el) => el.group)] : [];
+};
+
+const add = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitizeManagers,
+    sanitizeTimezones,
+    sanitizeGroups,
+    sanitize(fieldsToSend),
+    camelToSnake(['custom']),
+  ]);
+  try {
+    const response = await contactService.createContact(item);
+    return applyTransform(response.data, [snakeToCamel(['custom'])]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const update = async ({ itemInstance }) => {
+  const { etag } = itemInstance;
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitizeManagers,
+    sanitizeTimezones,
+    sanitizeGroups,
+    sanitize(fieldsToSend),
+    camelToSnake(['custom']),
+  ]);
+  try {
+    const response = await contactService.updateContact(etag, item);
+    return applyTransform(response.data, [snakeToCamel(['custom'])]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteContact = async ({ id }) => {
+  try {
+    const response = await contactService.deleteContact(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getContactsLookup = (params) =>
+  getList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const ContactsAPI = {
+  getList,
+  get,
+  add,
+  update,
+  delete: deleteContact,
+  getLookup: getContactsLookup,
+};
+
+export default ContactsAPI;

package/src/api/clients//321/201ontacts/enums/ContactsSearchMode.ts

@@ -0,0 +1,9 @@
+const ContactsSearchMode = Object.freeze({
+  NAME: 'name',
+  LABELS: 'labels',
+  ABOUT: 'about',
+  VARIABLES: 'variables',
+  DESTINATION: 'destination',
+});
+
+export default ContactsSearchMode;

package/src/api/clients//321/201ontacts/index.ts

@@ -0,0 +1,5 @@
+import contactChatMessagesHistory from './contactChatMessagesHistory';
+import contacts from './contacts';
+import ContactsSearchMode from './enums/ContactsSearchMode';
+
+export { contactChatMessagesHistory, contacts, ContactsSearchMode };

package/src/api/defaults/getDefaultGetListResponse/getDefaultGetListResponse.ts

@@ -0,0 +1,6 @@
+const getDefaultGetListResponse = ({} = {}) => ({
+  items: [],
+  next: false,
+});
+
+export default getDefaultGetListResponse;

package/src/api/defaults/getDefaultGetParams/getDefaultGetParams.ts

@@ -0,0 +1,6 @@
+const getDefaultGetParams = ({ page = 1, size = 10 } = {}) => ({
+  page,
+  size,
+});
+
+export default getDefaultGetParams;

package/src/api/defaults/getDefaultInstance/getDefaultInstance.ts

@@ -0,0 +1,21 @@
+import qs from 'qs';
+import generateInstance from '../../axios/generateInstance';
+import updateTokenInterceptor from '../../interceptors/request/updateToken.interceptor';
+import handleUnauthorizedInterceptor from '../../interceptors/response/handleUnauthorized.interceptor';
+
+const getDefaultInstance = () => {
+  return generateInstance({
+    interceptors: {
+      request: [updateTokenInterceptor],
+      response: [handleUnauthorizedInterceptor],
+    },
+    baseURL: import.meta.env.VITE_API_URL,
+    paramsSerializer: (params) => {
+      return qs.stringify(params);
+    },
+  });
+};
+
+export { getDefaultInstance };
+
+export default getDefaultInstance;

package/src/api/defaults/getDefaultOpenAPIConfig/getDefaultOpenAPIConfig.ts

@@ -0,0 +1,10 @@
+import { Configuration } from 'webitel-sdk';
+
+const getDefaultOpenAPIConfig = () =>
+  new Configuration({
+    basePath: import.meta.env.VITE_API_URL,
+    apiKey: localStorage.getItem('access-key') || '',
+    accessToken: localStorage.getItem('access-key') || '',
+  });
+
+export default getDefaultOpenAPIConfig;

package/src/api/defaults/index.ts

@@ -0,0 +1,11 @@
+import getDefaultGetListResponse from './getDefaultGetListResponse/getDefaultGetListResponse';
+import getDefaultGetParams from './getDefaultGetParams/getDefaultGetParams';
+import getDefaultInstance from './getDefaultInstance/getDefaultInstance';
+import getDefaultOpenAPIConfig from './getDefaultOpenAPIConfig/getDefaultOpenAPIConfig';
+
+export {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+};

package/src/api/index.ts

@@ -0,0 +1,6 @@
+// Export all nested directories' contents
+export * from './axios';
+export * from './clients';
+export * from './defaults';
+export * from './interceptors';
+export * from './transformers';

package/src/api/interceptors/index.ts

@@ -0,0 +1,3 @@
+// Export interceptors
+export * from './request';
+export * from './response';

package/src/api/interceptors/request/index.ts

@@ -0,0 +1,2 @@
+// Export request interceptors
+export { default as updateTokenInterceptor } from './updateToken.interceptor';

package/src/api/interceptors/request/updateToken.interceptor.ts

@@ -0,0 +1,10 @@
+const updateTokenInterceptor = [
+  (config) => {
+    config.headers['X-Webitel-Access'] =
+      localStorage.getItem('access-token') || '';
+    return config;
+  },
+  (error) => Promise.reject(error),
+];
+
+export default updateTokenInterceptor;

package/src/api/interceptors/response/handleUnauthorized.interceptor.ts

@@ -0,0 +1,12 @@
+const handleUnauthorizedInterceptor = [
+  (response) => response,
+  (error) => {
+    if (error.response && error.response.status === 401) {
+      console.warn('intercepted 401');
+      localStorage.removeItem('access-token');
+    }
+    return Promise.reject(error);
+  },
+];
+
+export default handleUnauthorizedInterceptor;

package/src/api/interceptors/response/index.ts

@@ -0,0 +1,2 @@
+// Export response interceptors
+export { default as handleUnauthorizedInterceptor } from './handleUnauthorized.interceptor';

package/src/api/transformers/addQueryParamsToUrl/addQueryParamsToUrl.transformer.ts

@@ -0,0 +1,19 @@
+// @author @stanislav-kozak
+// This function adds query parameters to a given URL.
+// Where queryArray is an array of query parameters in the format 'key=value'.
+const addQueryParamsToUrl = (queryArray) => (url) => {
+  let modifyUrl = url;
+
+  if (queryArray && queryArray.length > 0) {
+    if (modifyUrl.includes('?')) {
+      modifyUrl += '&' + queryArray.join('&');
+
+      return modifyUrl;
+    }
+
+    modifyUrl += '?' + queryArray.join('&');
+  }
+
+  return modifyUrl;
+};
+export default addQueryParamsToUrl;

package/src/api/transformers/applyTransform.ts

@@ -0,0 +1,17 @@
+const applyTransform = (
+  target,
+  transformers,
+  { debug = false, withContext = null } = {},
+) => {
+  return transformers.reduce((result, transformer, index) => {
+    if (debug) console.info(`applyTransform debug on step ${index}`, result);
+
+    if (withContext) {
+      return transformer(result, withContext);
+    }
+
+    return transformer(result);
+  }, target);
+};
+
+export default applyTransform;

package/src/api/transformers/camelToSnake/camelToSnake.transformer.ts

@@ -0,0 +1,5 @@
+import { objCamelToSnake } from '../../../scripts/caseConverters';
+
+const camelToSnakeTransformer = (skipKeys) => (obj) =>
+  objCamelToSnake(obj, skipKeys);
+export default camelToSnakeTransformer;

package/src/api/transformers/generateUrl/generateUrl.transformer.ts

@@ -0,0 +1,13 @@
+import qs from 'query-string';
+
+const generateUrlTransformer = (baseUrl) => (params) => {
+  const stringifyOptions = {
+    skipEmptyString: true,
+    skipNull: true,
+  };
+
+  const url = `${baseUrl}?${qs.stringify(params, stringifyOptions)}`;
+  return url;
+};
+
+export default generateUrlTransformer;

package/src/api/transformers/index.ts

@@ -0,0 +1,28 @@
+import addQueryParamsToUrl from './addQueryParamsToUrl/addQueryParamsToUrl.transformer';
+import applyTransform from './applyTransform';
+import camelToSnake from './camelToSnake/camelToSnake.transformer';
+import generateUrl from './generateUrl/generateUrl.transformer';
+import log from './log/log.transformer';
+import merge from './merge/merge.transformer';
+import mergeEach from './mergeEach/mergeEach.transformer';
+import notify from './notify/notify.transformer';
+import sanitize from './sanitize/sanitize.transformer';
+import { skipIf } from './skipIf/skipIf';
+import snakeToCamel from './snakeToCamel/snakeToCamel.transformer';
+import starToSearch from './starToSearch/starToSearch.transformer';
+
+export {
+  addQueryParamsToUrl,
+  camelToSnake,
+  generateUrl,
+  log,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  skipIf,
+  snakeToCamel,
+  starToSearch,
+};
+
+export default applyTransform;

package/src/api/transformers/log/log.transformer.ts

@@ -0,0 +1,6 @@
+const logTransformer = (arg) => {
+  console.log(arg);
+  return arg;
+};
+
+export default logTransformer;

package/src/api/transformers/merge/merge.transformer.ts

@@ -0,0 +1,8 @@
+import merge from 'deepmerge';
+
+const mergeTransformer =
+  (...args) =>
+  (main) =>
+    merge.all([...args, main]);
+
+export default mergeTransformer;

package/src/api/transformers/mergeEach/mergeEach.transformer.ts

@@ -0,0 +1,8 @@
+import merge from 'deepmerge';
+
+const mergeEachTransformer =
+  (...args) =>
+  (main) =>
+    main.map((item) => merge.all([...args, item]));
+
+export default mergeEachTransformer;

package/src/api/transformers/notify/notify.transformer.ts

@@ -0,0 +1,39 @@
+import eventBus from '../../../scripts/eventBus';
+
+const notifyTransformer = (notificationObject) => {
+  /*
+  if passed arg is function, then this notification - static content,
+  predefined before actual transformer is called in applyTransform flow
+   */
+  if (typeof notificationObject === 'function') {
+    /*
+    so, create a callback which will send notification with params, passed to it
+     */
+    const callback = ({ type, text }) =>
+      eventBus.$emit('notification', {
+        type,
+        text,
+      });
+
+    /*
+    and, then, return a function, which will be called in main applyTransform flow,
+    calling passed arg function with callback, and returning actual notify payload
+     */
+    return (payload) => {
+      notificationObject({ callback });
+      return payload;
+    };
+  }
+  if (notificationObject instanceof Error) {
+    eventBus.$emit('notification', {
+      type: 'error',
+      text:
+        notificationObject.response?.data?.detail ||
+        notificationObject.response?.data?.message ||
+        notificationObject,
+    });
+  }
+  return notificationObject;
+};
+
+export default notifyTransformer;

package/src/api/transformers/sanitize/sanitize.transformer.ts

@@ -0,0 +1,12 @@
+const sanitizeTransformer = (fieldsToSend) => (item) => {
+  return Object.keys(item).reduce((sanitizedItem, key) => {
+    if (fieldsToSend.indexOf(key) === -1) return sanitizedItem;
+
+    return {
+      ...sanitizedItem,
+      [key]: item[key],
+    };
+  }, {});
+};
+
+export default sanitizeTransformer;

package/src/api/transformers/skipIf/skipIf.ts

@@ -0,0 +1,11 @@
+export const skipIf =
+  (
+    transformer: (...payload: unknown[]) => unknown,
+    ifFn: boolean | ((...payload: unknown[]) => boolean),
+  ) =>
+  (payload: unknown) => {
+    if (typeof ifFn === 'function' ? ifFn(payload) : ifFn) {
+      return payload;
+    }
+    return transformer(payload);
+  };

package/src/api/transformers/snakeToCamel/snakeToCamel.transformer.ts

@@ -0,0 +1,5 @@
+import { objSnakeToCamel } from '../../../scripts/caseConverters';
+
+const snakeToCamelTransformer = (skipKeys) => (obj) =>
+  objSnakeToCamel(obj, skipKeys);
+export default snakeToCamelTransformer;

package/src/api/transformers/starToSearch/starToSearch.transformer.ts

@@ -0,0 +1,15 @@
+import deepcopy from 'deep-copy';
+import get from 'lodash/get';
+
+import updateObject from '../../../scripts/updateObject';
+
+const starToSearchTransformer =
+  (path = 'search') =>
+  (params) => {
+    const copy = deepcopy(params);
+    const value = get(copy, path);
+    if (!value || value.slice(-1) === '*') return copy;
+    return updateObject({ obj: copy, path, value: `${value}*` });
+  };
+
+export default starToSearchTransformer;