@webitel/ui-sdk 24.4.19 → 24.4.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webitel/ui-sdk",
-  "version": "24.4.19",
+  "version": "24.4.21",
   "private": false,
   "scripts": {
     "dev": "vite",
@@ -39,6 +39,7 @@
     "@vuelidate/validators": "^2.0.4",
     "@vuepic/vue-datepicker": "^4.4.0",
     "@vueuse/components": "^10.7.2",
+    "axios": "^1.6.8",
     "clipboard-copy": "^4.0.1",
     "csv-stringify": "^5.5.3",
     "deep-copy": "^1.4.2",
@@ -57,7 +58,7 @@
     "vue-multiselect": "^3.0.0-beta.3",
     "vue-observe-visibility": "^2.0.0-alpha.1",
     "vue-router": "^4.1.6",
-    "webitel-sdk": "^23.7.5"
+    "webitel-sdk": "^24.2.6"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "5.0.4",

package/src/api/clients/agents/agents.js

@@ -0,0 +1,292 @@
+import { AgentServiceApiFactory } from 'webitel-sdk';
+import convertDuration from '../../../scripts/convertDuration';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultOpenAPIConfig,
+  getDefaultInstance,
+} from '../../defaults';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+
+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()),
+    starToSearch('search'),
+  ]);
+
+  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.js

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

package/src/api/clients/calendars/calendars.js

@@ -0,0 +1,248 @@
+import deepCopy from 'deep-copy';
+import { CalendarServiceApiFactory } from 'webitel-sdk';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultOpenAPIConfig,
+  getDefaultInstance,
+} from '../../defaults';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const calendarService = new CalendarServiceApiFactory(configuration, '', instance);
+
+const getCalendarList = async (params) => {
+  const {
+    page,
+    size,
+    search,
+    sort,
+    fields,
+    id,
+  } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await calendarService.searchCalendar(
+      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 getCalendar = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    const copy = deepCopy(item);
+    const defaultSingleObject = {
+      name: '',
+      timezone: {},
+      description: '',
+      startAt: Date.now(),
+      endAt: Date.now(),
+      expires: !!(copy.startAt || copy.endAt),
+      accepts: [],
+      excepts: [],
+    };
+    // eslint-disable-next-line no-param-reassign
+    copy.accepts = copy.accepts.map((accept) => ({
+      day: accept.day || 0,
+      disabled: accept.disabled || false,
+      start: accept.startTimeOfDay || 0,
+      end: accept.endTimeOfDay || 0,
+    }));
+    if (copy.excepts) {
+      // eslint-disable-next-line no-param-reassign
+      copy.excepts = copy.excepts.map((except) => ({
+        name: except.name || '',
+        date: except.date || 0,
+        repeat: except.repeat || false,
+        working: except.working || false,
+        workStart: except.workStart || null,
+        workStop: except.workStop || null,
+      }));
+    }
+    return { ...defaultSingleObject, ...copy };
+  };
+
+  try {
+    const response = await calendarService.readCalendar(id);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      itemResponseHandler,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const fieldsToSend = [
+  'name',
+  'description',
+  'timezone',
+  'startAt',
+  'endAt',
+  'day',
+  'accepts',
+  'excepts',
+  'startTimeOfDay',
+  'endTimeOfDay',
+  'disabled',
+  'date',
+  'repeat',
+  'working',
+  'workStart',
+  'workStop',
+];
+
+const preRequestHandler = (item) => {
+  const copy = deepCopy(item);
+  delete copy.timezone.offset;
+  if (!copy.expires) {
+    delete copy.startAt;
+    delete copy.endAt;
+  }
+
+  copy.accepts = copy.accepts.map((accept) => ({
+    day: accept.day,
+    disabled: accept.disabled,
+    startTimeOfDay: accept.start,
+    endTimeOfDay: accept.end,
+  }));
+  return copy;
+};
+
+const addCalendar = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await calendarService.createCalendar(item);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const updateCalendar = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await calendarService.updateCalendar(id, item);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const deleteCalendar = async ({ id }) => {
+  try {
+    const response = await calendarService.deleteCalendar(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const getCalendarsLookup = (params) => getCalendarList({
+  ...params,
+  fields: params.fields || ['id', 'name'],
+});
+
+const getTimezonesLookup = async (params) => {
+  const {
+    page,
+    size,
+    search,
+    sort,
+    fields,
+    id,
+  } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+  ]);
+
+  try {
+    const response = await calendarService.searchTimezones(
+      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 CalendarsAPI = {
+  getList: getCalendarList,
+  get: getCalendar,
+  add: addCalendar,
+  update: updateCalendar,
+  delete: deleteCalendar,
+  getLookup: getCalendarsLookup,
+  getTimezonesLookup,
+};
+
+export default CalendarsAPI;