@webitel/api-services 0.0.23 → 0.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webitel/api-services",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "private": false,
   "scripts": {
     "make-all": "npm run gen:api && npm version patch && npm run publish-lib",
@@ -17,21 +17,25 @@
   },
   "type": "module",
   "exports": {
+    "./api": {
+      "types": "./types/api/index.d.ts",
+      "import": "./src/api/index.ts"
+    },
     "./gen": {
-      "import": "./src/gen/index.ts",
-      "types": "./types/gen/index.d.ts"
+      "types": "./types/gen/index.d.ts",
+      "import": "./src/gen/index.ts"
     },
     "./utils": {
-      "import": "./src/utils/index.ts",
-      "types": "./types/utils/index.d.ts"
+      "types": "./types/utils/index.d.ts",
+      "import": "./src/utils/index.ts"
     },
     "./gen/utils": {
-      "import": "./src/utils/gen/index.ts",
-      "types": "./types/utils/gen/index.d.ts"
+      "types": "./types/utils/gen/index.d.ts",
+      "import": "./src/utils/gen/index.ts"
     },
     "./gen/models": {
-      "import": "./src/gen/_models/index.ts",
-      "types": "./types/gen/_models/index.d.ts"
+      "types": "./types/gen/_models/index.d.ts",
+      "import": "./src/gen/_models/index.ts"
     }
   },
   "files": [
@@ -40,7 +44,6 @@
     "CHANGELOG.md"
   ],
   "peerDependencies": {
-    "axios": "^1.8.3",
     "deep-copy": "^1.4.2",
     "deep-equal": "^2.2.3",
     "deepmerge": "^4.3.1",
@@ -52,6 +55,7 @@
     "@biomejs/biome": "1.9.4",
     "@tsconfig/node22": "^22.0.0",
     "@types/node": "^22.13.10",
+    "axios": "^1.10.0",
     "change-case": "^5.4.4",
     "globby": "^14.1.0",
     "husky": "^9.1.7",

package/src/api/axios/generateInstance.ts

@@ -0,0 +1,30 @@
+import axios from 'axios';
+
+// 'X-Webitel-Access' ~ 'X-Access-Token'
+const generateInstance = ({ interceptors, baseURL, ...rest } = {}) => {
+  const instance = axios.create({
+    baseURL,
+    headers: {
+      'X-Webitel-Access': localStorage.getItem('access-token') || '',
+    },
+    ...rest,
+  });
+
+  if (interceptors) {
+    const { request, response } = interceptors;
+    if (request) {
+      for (const interceptor of request) {
+        instance.interceptors.request.use(...interceptor);
+      }
+    }
+    if (response) {
+      for (const interceptor of response) {
+        instance.interceptors.response.use(...interceptor);
+      }
+    }
+  }
+
+  return instance;
+};
+
+export default generateInstance;

package/src/api/axios/index.ts

@@ -0,0 +1,2 @@
+// Export axios directory contents
+export { default as generateInstance } from './generateInstance';

package/src/api/clients/_shared/generatePermissionsApi.ts

@@ -0,0 +1,97 @@
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+
+const permissionsUrl = 'acl';
+
+const handlePermissionsList = (items) => {
+  return items.map((item) => ({
+    ...item,
+    access: {
+      x: {
+        id: (item.granted.match(/x/g) || []).length + 1,
+        rule: 'x'.repeat((item.granted.match(/x/g) || []).length),
+      },
+      r: {
+        id: (item.granted.match(/r/g) || []).length + 1,
+        rule: 'r'.repeat((item.granted.match(/r/g) || []).length),
+      },
+      w: {
+        id: (item.granted.match(/w/g) || []).length + 1,
+        rule: 'w'.repeat((item.granted.match(/w/g) || []).length),
+      },
+      d: {
+        id: (item.granted.match(/d/g) || []).length + 1,
+        rule: 'd'.repeat((item.granted.match(/d/g) || []).length),
+      },
+    },
+  }));
+};
+
+export const generatePermissionsApi = (baseUrl) => {
+  const instance = getDefaultInstance();
+
+  const getList = async ({ parentId, ...params }) => {
+    const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+    const defaultObject = {
+      user: false,
+    };
+
+    const url = applyTransform(params, [
+      merge(getDefaultGetParams()),
+      starToSearch('search'),
+      (params) => ({
+        ...params,
+        q: params.search,
+      }),
+      sanitize(fieldsToSend),
+      camelToSnake(),
+      generateUrl(`${baseUrl}/${parentId}/${permissionsUrl}`),
+    ]);
+    try {
+      const response = await instance.get(url);
+      const { items, next } = applyTransform(response.data, [
+        snakeToCamel(),
+        merge(getDefaultGetListResponse()),
+      ]);
+      return {
+        items: applyTransform(items, [
+          mergeEach(defaultObject),
+          handlePermissionsList,
+        ]),
+        next,
+      };
+    } catch (err) {
+      throw applyTransform(err, [notify]);
+    }
+  };
+
+  const patch = async ({ changes, id }) => {
+    const body = applyTransform(changes, [camelToSnake()]);
+    const url = `${baseUrl}/${id}/${permissionsUrl}`;
+    try {
+      const response = await instance.patch(url, body);
+      return applyTransform(response.data, [snakeToCamel()]);
+    } catch (err) {
+      throw applyTransform(err, [notify]);
+    }
+  };
+
+  return {
+    getPermissionsList: getList,
+    patchPermissions: patch,
+  };
+};

package/src/api/clients/agents/agentChats.ts

@@ -0,0 +1,74 @@
+import { AgentChatServiceApiFactory } from 'webitel-sdk';
+
+import i18n from '../../../locale/i18n';
+import {
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  merge,
+  notify,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+
+const { t } = i18n.global;
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const agentChatsService = new AgentChatServiceApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const getChatsList = async (params) => {
+  const { size, page, onlyClosed, onlyUnprocessed } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+  ]);
+
+  try {
+    const response = await agentChatsService.getAgentChats(
+      size,
+      page,
+      undefined,
+      undefined,
+      undefined,
+      onlyClosed,
+      onlyUnprocessed,
+    );
+    const { items, next } = applyTransform(response.data, [snakeToCamel()]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const markChatProcessed = async (chatId) => {
+  // add to chat unprocessedClose: true
+  try {
+    const response = await agentChatsService.markChatProcessed(chatId);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify(({ callback }) =>
+        callback({
+          type: 'error',
+          text: t('errorNotifications.markChatProcessed'),
+        }),
+      ),
+    ]);
+  }
+};
+
+const AgentChatsAPI = {
+  getList: getChatsList,
+  markChatProcessed,
+};
+
+export default AgentChatsAPI;

package/src/api/clients/agents/agents.ts

@@ -0,0 +1,265 @@
+import { AgentServiceApiFactory } from 'webitel-sdk';
+
+import convertDuration from '../../../scripts/convertDuration';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const agentService = new AgentServiceApiFactory(configuration, '', instance);
+
+const convertStatusDuration = (value) => {
+  if (value > 60 * 60 * 24) return '>24:00:00';
+  return convertDuration(value);
+};
+
+const getAgentsList = async (params) => {
+  const listResponseHandler = (items) => {
+    return items.map((item) => ({
+      ...item,
+      statusDuration: convertStatusDuration(item.statusDuration),
+    }));
+  };
+
+  const {
+    page,
+    size,
+    search,
+    sort,
+    fields,
+    id,
+    team,
+    skill,
+    isSupervisor,
+    isNotSupervisor,
+    notTeamId,
+    supervisorId,
+    notSkillId,
+  } = applyTransform(params, [merge(getDefaultGetParams())]);
+
+  try {
+    const response = await agentService.searchAgent(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+      id,
+      undefined,
+      supervisorId,
+      team,
+      undefined,
+      undefined,
+      isSupervisor,
+      skill,
+      undefined,
+      isNotSupervisor,
+      undefined,
+      undefined,
+      notTeamId,
+      notSkillId,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, [listResponseHandler]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getAgent = async ({ itemId: id }) => {
+  const defaultObject = {
+    user: {},
+    team: {},
+    supervisor: [],
+    auditor: [],
+    region: {},
+    progressiveCount: 0,
+    chatCount: 0,
+    taskCount: 0,
+    isSupervisor: false,
+    description: '',
+    greetingMedia: {},
+  };
+
+  try {
+    const response = await agentService.readAgent(id);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      merge(defaultObject),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const fieldsToSend = [
+  'user',
+  'team',
+  'supervisor',
+  'auditor',
+  'region',
+  'greetingMedia',
+  'progressiveCount',
+  'chatCount',
+  'taskCount',
+  'isSupervisor',
+];
+
+const addAgent = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await agentService.createAgent(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const patchAgent = async ({ changes, id }) => {
+  const body = applyTransform(changes, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await agentService.patchAgent(id, body);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateAgent = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await agentService.updateAgent(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteAgent = async ({ id }) => {
+  try {
+    const response = await agentService.deleteAgent(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getAgentsLookup = (params) =>
+  getAgentsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const getAgentHistory = async (params) => {
+  const {
+    parentId,
+    from,
+    to,
+    page,
+    size,
+    sort = '-joined_at',
+  } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await agentService.searchAgentStateHistory(
+      page,
+      size,
+      from,
+      to,
+      parentId,
+      sort,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getAgentUsersOptions = async (params) => {
+  const { page, size, search, sort, fields, id } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await agentService.searchLookupUsersAgentNotExists(
+      page,
+      size,
+      search,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+const getSupervisorOptions = async (params) => {
+  const isSupervisor = true;
+  return getAgentsList({ ...params, isSupervisor });
+};
+
+const getRegularAgentsOptions = async (params) => {
+  const isNotSupervisor = true;
+  return getAgentsList({ ...params, isNotSupervisor });
+};
+
+const AgentsAPI = {
+  getList: getAgentsList,
+  get: getAgent,
+  add: addAgent,
+  patch: patchAgent,
+  update: updateAgent,
+  delete: deleteAgent,
+  getLookup: getAgentsLookup,
+
+  getAgentHistory,
+  getRegularAgentsOptions,
+  getAgentUsersOptions,
+  getSupervisorOptions,
+};
+
+export default AgentsAPI;

package/src/api/clients/buckets/buckets.ts

@@ -0,0 +1,112 @@
+import { BucketServiceApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const bucketService = new BucketServiceApiFactory(configuration, '', instance);
+
+const getBucketsList = async (params) => {
+  const { page, size, search, sort, fields, id } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await bucketService.searchBucket(
+      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 getBucket = async ({ itemId: id }) => {
+  try {
+    const response = await bucketService.readBucket(id);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const fieldsToSend = ['name', 'description'];
+
+const addBucket = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await bucketService.createBucket(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateBucket = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await bucketService.updateBucket(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteBucket = async ({ id }) => {
+  try {
+    const response = await bucketService.deleteBucket(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getBucketsLookup = (params) =>
+  getBucketsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const BucketsAPI = {
+  getList: getBucketsList,
+  get: getBucket,
+  add: addBucket,
+  update: updateBucket,
+  delete: deleteBucket,
+  getLookup: getBucketsLookup,
+};
+
+export default BucketsAPI;