@webitel/ui-sdk 24.4.19 → 24.4.21

package/src/api/clients/media/media.js

@@ -0,0 +1,136 @@
+import axios from 'axios';
+import { MediaFileServiceApiFactory } from 'webitel-sdk';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults';
+import applyTransform, {
+  merge,
+  notify,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const mediaService = new MediaFileServiceApiFactory(configuration, '', instance);
+
+const token = localStorage.getItem('access-token');
+const baseUrl = import.meta.env.VITE_API_URL;
+
+const getMediaList = async (params) => {
+  const {
+    page,
+    size,
+    search,
+    sort,
+    fields,
+    id,
+  } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await mediaService.searchMediaFile(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+      id,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const getMedia = async ({ itemId }) => {
+  const url = `${baseUrl}/storage/media/${itemId}/stream?access_token=${token}`;
+  try {
+    return await instance.get(url);
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+export const downloadMedia = async (id) => {
+  const url = `${baseUrl}/storage/media/${id}/download?access_token=${token}`;
+  try {
+    return await instance.get(url);
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const addMediaInstance = axios.create({
+  headers: {
+    'content-type': 'multipart/form-data',
+  },
+});
+
+const addMedia = async (params) => {
+  const url = `${baseUrl}/storage/media?access_token=${token}`;
+
+  const formData = new FormData();
+  formData.append('file', params.itemInstance);
+  try {
+    const response = await addMediaInstance.post(url, formData);
+    applyTransform(response, [
+      notify(() => ({ type: 'info', text: 'Successfully added' })),
+    ]);
+    return response;
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const deleteMedia = async ({ id }) => {
+  try {
+    const response = await mediaService.deleteMediaFile(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const getMediaLookup = (params) => getMediaList({
+  ...params,
+  fields: params.fields || ['id', 'name'],
+});
+
+const MediaAPI = {
+  getList: getMediaList,
+  get: getMedia,
+  add: addMedia,
+  delete: deleteMedia,
+  getLookup: getMediaLookup,
+};
+
+export default MediaAPI;

package/src/api/clients/queues/defaults/processing.js

@@ -0,0 +1,10 @@
+import deepmerge from 'deepmerge';
+
+const processing = (processing = {}) => (deepmerge({
+  enabled: false,
+  formSchema: {},
+  sec: 30,
+  renewalSec: 15,
+}, processing));
+
+export default processing;

package/src/api/clients/queues/queues.js

@@ -0,0 +1,275 @@
+import { QueueServiceApiFactory } from 'webitel-sdk';
+import deepCopy from 'deep-copy';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+import isEmpty from '../../../scripts/isEmpty';
+import processing from './defaults/processing';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const queueService = new QueueServiceApiFactory(configuration, '', instance);
+
+const doNotConvertKeys = ['variables'];
+
+const fieldsToSend = [
+  'name',
+  'type',
+  'strategy',
+  'team',
+  'priority',
+  'dncList',
+  'schema',
+  'payload',
+  'taskProcessing',
+  'maxOfRetry',
+  'timeout',
+  'secBetweenRetries',
+  'variables',
+  'calendar',
+  'description',
+  'enabled',
+  'ringtone',
+  'doSchema',
+  'afterSchema',
+  'stickyAgent',
+  'grantee',
+  'tags',
+];
+
+const preRequestHandler = (item) => {
+  const copy = deepCopy(item);
+  copy.variables = copy.variables.reduce((variables, variable) => {
+    if (!variable.key) return variables;
+    return { ...variables, [variable.key]: variable.value };
+  }, {});
+  return copy;
+};
+
+const getQueuesList = async (params) => {
+  const defaultObject = {
+    type: 0,
+    enabled: false,
+    active: 0,
+    waiting: 0,
+    priority: '0',
+  };
+
+  const {
+    page,
+    size,
+    search,
+    sort,
+    fields,
+    id,
+    queueType,
+    team,
+    tags,
+  } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await queueService.searchQueue(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+      id,
+      queueType,
+      team,
+      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 getQueue = async ({ itemId: id }) => {
+  const defaultObject = {
+    tags: [],
+    type: 0,
+    formSchema: {},
+    taskProcessing: {},
+  };
+  const responseHandler = (item) => {
+    const copy = deepCopy(item);
+    try {
+      if (copy.variables) {
+        copy.variables = Object.keys(copy.variables)
+        .map((key) => ({
+          key,
+          value: copy.variables[key],
+        }));
+      }
+      if (isEmpty(copy.taskProcessing)) {
+        copy.taskProcessing = processing({
+          enabled: !!copy.processing,
+          formSchema: copy.formSchema,
+          sec: copy.processingSec || 0,
+          renewalSec: copy.processingRenewalSec || 0,
+        });
+      }
+      return copy;
+    } catch (err) {
+      throw err;
+    }
+  };
+  try {
+    const response = await queueService.readQueue(id);
+    return applyTransform(response.data, [
+      snakeToCamel(doNotConvertKeys),
+      merge(defaultObject),
+      responseHandler,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const addQueue = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    camelToSnake(doNotConvertKeys),
+  ]);
+  try {
+    const response = await queueService.createQueue(item);
+    return applyTransform(response.data, [
+      snakeToCamel(doNotConvertKeys),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const updateQueue = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    camelToSnake(doNotConvertKeys),
+  ]);
+  try {
+    const response = await queueService.updateQueue(id, item);
+    return applyTransform(response.data, [
+      snakeToCamel(doNotConvertKeys),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const patchQueue = async ({ id, changes }) => {
+  const item = applyTransform(changes, [
+    sanitize(fieldsToSend),
+    camelToSnake(doNotConvertKeys),
+  ]);
+  try {
+    const response = await queueService.patchQueue(id, item);
+    return applyTransform(response.data, [
+      snakeToCamel(doNotConvertKeys),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const deleteQueue = async ({ id }) => {
+  try {
+    const response = await queueService.deleteQueue(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const getQueuesLookup = (params) => getQueuesList({
+  ...params,
+  fields: params.fields || ['id', 'name', 'type'],
+});
+
+const getQueuesTags = async (params) => {
+  const {
+    page,
+    size,
+    search,
+    sort,
+    fields,
+  } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch(),
+    camelToSnake(doNotConvertKeys),
+  ]);
+  try {
+    const response = await queueService.searchQueueTags(
+        page,
+        size,
+        search,
+        sort,
+        fields,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(doNotConvertKeys),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const QueuesAPI = {
+  getList: getQueuesList,
+  get: getQueue,
+  add: addQueue,
+  patch: patchQueue,
+  update: updateQueue,
+  delete: deleteQueue,
+  getLookup: getQueuesLookup,
+  getQueuesTags,
+};
+
+export default QueuesAPI;

package/src/api/clients/roles/roles.js

@@ -0,0 +1,213 @@
+import deepCopy from 'deep-copy';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../defaults';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+import ApplicationsAccess
+  from '../../../modules/Userinfo/classes/ApplicationsAccess';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/roles';
+const fieldsToSend = ['name', 'description', 'permissions', 'metadata'];
+
+const preRequestHandler = (item) => {
+  const copy = deepCopy(item);
+  copy.metadata.access = ApplicationsAccess.minify(copy.metadata.access);
+  return copy;
+};
+
+const getRoleList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  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,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const getRole = async ({ itemId: id }) => {
+  const defaultObject = {
+    name: '',
+    description: '',
+    permissions: [],
+    metadata: {},
+  };
+
+  const itemResponseHandler = (response) => {
+    const copy = deepCopy(response);
+    copy.metadata.access = new ApplicationsAccess({ access: copy.metadata.access }).getAccess();
+    return copy;
+  };
+
+  const url = `${baseUrl}/${id}?fields=metadata&fields=permissions&fields=name&fields=description`;
+
+  try {
+    const response = await instance.get(url);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      merge(defaultObject),
+      itemResponseHandler,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const getExtendedRoles = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  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,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const addRole = 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 updateRole = 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 deleteRole = async ({ id }) => {
+  const url = `${baseUrl}/${id}`;
+  try {
+    const response = await instance.delete(url);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const getRolesLookup = (params) => getRoleList({
+  ...params,
+  fields: params.fields || ['id', 'name'],
+});
+
+const PERMISSIONS_LIST_URL = '/permissions';
+
+const getPermissionsOptions = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const url = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+    generateUrl(PERMISSIONS_LIST_URL),
+  ]);
+  try {
+    const response = await instance.get(url);
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const RolesAPI = {
+  getList: getRoleList,
+  get: getRole,
+  add: addRole,
+  update: updateRole,
+  delete: deleteRole,
+  getLookup: getRolesLookup,
+
+  getExtendedRoles,
+  getPermissionsOptions,
+};
+
+export default RolesAPI;