@webitel/ui-sdk 24.12.121 → 24.12.122

package/src/api/clients/contactGroups/contactGroups.js

@@ -0,0 +1,162 @@
+import { GroupsApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index.js';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index.js';
+import { generatePermissionsApi } from '../_shared/generatePermissionsApi.js';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const contactGroupsService = new GroupsApiFactory(configuration, '', instance);
+
+const baseUrl = '/contacts/groups';
+
+const fieldsToSend = [
+  'name',
+  'description',
+  'enabled',
+  'type',
+  'default_group',
+];
+
+const getContactGroupsList = async (params) => {
+  const fieldsToSend = [
+    'page',
+    'size',
+    'q',
+    'sort',
+    'fields',
+    'type',
+    'enabled',
+    'id',
+  ];
+  const defaultObject = {
+    enabled: false,
+  };
+
+  const { page, size, fields, sort, id, q, name, type, enabled } =
+    applyTransform(params, [
+      merge(getDefaultGetParams()),
+      starToSearch('search'),
+      (params) => ({ ...params, q: params.search }),
+      sanitize(fieldsToSend),
+      camelToSnake(),
+    ]);
+
+  try {
+    const response = await contactGroupsService.listGroups(
+      page,
+      size,
+      fields,
+      sort,
+      id,
+      q,
+      name,
+      type,
+      enabled,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, [mergeEach(defaultObject)]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getContactGroup = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => item.group;
+
+  try {
+    const response = await contactGroupsService.locateGroup(id, fieldsToSend);
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addStaticContactGroup = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await contactGroupsService.createGroup(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateStaticContactGroup = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await contactGroupsService.updateGroup(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const patchStaticContactGroup = async ({ id, changes }) => {
+  const item = applyTransform(changes, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await contactGroupsService.updateGroup2(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteStaticContactGroup = async ({ id }) => {
+  try {
+    const response = await contactGroupsService.deleteGroup(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getLookup = (params) =>
+  getContactGroupsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const ContactGroupsAPI = {
+  getList: getContactGroupsList,
+  get: getContactGroup,
+  add: addStaticContactGroup,
+  update: updateStaticContactGroup,
+  patch: patchStaticContactGroup,
+  delete: deleteStaticContactGroup,
+  getLookup,
+
+  ...generatePermissionsApi(baseUrl),
+};
+
+export default ContactGroupsAPI;

package/src/api/clients/index.js

@@ -15,7 +15,15 @@ import roles from './roles/roles.js';
 import skills from './skills/skills.js';
 import teams from './teams/teams.js';
 import users from './users/users.js';
+import caseSources from './caseSources/caseSources.js';
+import casePriorities from './casePriorities/casePriorities.js';
 import { contactChatMessagesHistory, contacts } from './сontacts/index.js';
+import slas from './slas/slas.js';
+import caseCloseReasonGroups from './caseCloseReasonGroups/caseCloseReasonGroups.js';
+import caseCloseReasons from './caseCloseReasons/caseCloseReasons.js';
+import caseStatuses from './caseStatuses/caseStatuses.js';
+import caseStatusConditions from './caseStatusConditions/caseStatusConditions.js';
+import contactGroups from './contactGroups/contactGroups.js';
 
 export {
   agents,
@@ -37,4 +45,12 @@ export {
   configurations,
   contacts,
   contactChatMessagesHistory,
+  caseSources,
+  casePriorities,
+  slas,
+  caseCloseReasonGroups,
+  caseCloseReasons,
+  caseStatuses,
+  caseStatusConditions,
+  contactGroups,
 };

package/src/api/clients/slaConditions/slaConditions.js

@@ -0,0 +1,167 @@
+import { SLAConditionsApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index.js';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index.js';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const slaConditionsService = new SLAConditionsApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const fieldsToSend = [
+  'name',
+  'priorities',
+  'sla_id',
+  'reaction_time',
+  'resolution_time',
+];
+
+const getConditionsList = async ({ parentId, ...rest }) => {
+  const fieldsToSend = [
+    'page',
+    'size',
+    'q',
+    'sort',
+    'fields',
+    'id',
+    'slaConditionId',
+    'priorityId',
+  ];
+
+  const {
+    page,
+    size,
+    fields,
+    sort,
+    id,
+    q,
+    sla_condition_id: slaConditionId,
+    priority_id: priorityId,
+  } = applyTransform(rest, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+
+  try {
+    const response = await slaConditionsService.listSLAConditions(
+      parentId,
+      page,
+      size,
+      fields,
+      sort,
+      id,
+      q,
+      slaConditionId,
+      priorityId,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, [snakeToCamel()]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getCondition = async ({ parentId, itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    return item.slaCondition;
+  };
+
+  try {
+    const response = await slaConditionsService.locateSLACondition(
+      parentId,
+      id,
+      fieldsToSend,
+    );
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateCondition = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await slaConditionsService.updateSLACondition(
+      itemInstance.slaId,
+      id,
+      item,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addCondition = async ({ itemInstance, parentId }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await slaConditionsService.createSLACondition(
+      parentId,
+      item,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteCondition = async ({ id, parentId }) => {
+  try {
+    const response = await slaConditionsService.deleteSLACondition(
+      parentId,
+      id,
+    );
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getLookup = async (params) =>
+  getConditionsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const SLAConditionsAPI = {
+  getList: getConditionsList,
+  get: getCondition,
+  update: updateCondition,
+  delete: deleteCondition,
+  add: addCondition,
+  getLookup,
+};
+
+export default SLAConditionsAPI;

package/src/api/clients/slas/slas.js

@@ -0,0 +1,129 @@
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index.js';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers/index.js';
+import { SLAsApiFactory } from 'webitel-sdk';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const slaService = new SLAsApiFactory(configuration, '', instance);
+
+const fieldsToSend = ['name', 'description', 'valid_from', 'valid_to', 'calendar', 'reaction_time', 'resolution_time'];
+
+const getSlasList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const {
+    page,
+    size,
+    fields,
+    sort,
+    id,
+    q,
+  } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await slaService.listSLAs(
+      page,
+      size,
+      fields,
+      sort,
+      id,
+      q,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, []),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getSla = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    return item.sla;
+  };
+
+  try {
+    const response = await slaService.locateSLA(id, fieldsToSend);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      itemResponseHandler,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addSla = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await slaService.createSLA(item);
+    return applyTransform(response.data, [
+      snakeToCamel()
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateSla = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend)]);
+  try {
+    const response = await slaService.updateSLA(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteSla = async ({ id }) => {
+  try {
+    const response = await slaService.deleteSLA(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getSlasLookup = (params) =>
+  getSlasList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const SlasAPI = {
+  getList: getSlasList,
+  getLookup: getSlasLookup,
+  get: getSla,
+  add: addSla,
+  update: updateSla,
+  delete: deleteSla,
+}
+
+export default SlasAPI;

package/src/locale/en/en.js

@@ -80,6 +80,8 @@ export default {
     read: 'Read',
     create: 'Create',
     draggable: 'Draggable',
+    unassigned: 'Unassigned',
+    showUnassigned: 'Show unassigned',
   },
   // yak zhe ya zaebalsya povtoriaty odni i ti sami slova!!!!
   vocabulary: {
@@ -153,11 +155,11 @@ export default {
     hasOption: 'Has option',
     hasRecording: 'Has recording',
     amdResult: 'AMD result',
-    evaluation: 'Evaluation',
     ratedBy: 'Rated by',
     talkDuration: 'Talk duration',
     totalDuration: 'Total duration',
     transcription: 'Transcription',
+    attachment: 'Attachment | Attachments',
     queue: {
       queue: 'Queue | Queues',
       type: {
@@ -227,6 +229,24 @@ export default {
       [CallDirection.Outbound]: 'Outbound',
     },
   },
+  cases: {
+    status: 'Status',
+    source: 'Source',
+    author: 'Author',
+    reporter: 'Reporter',
+    impacted: 'Impacted',
+    assignee: 'Assignee',
+    group: 'Group',
+    reason: 'Reason | Reasons',
+    rating: 'Rating',
+    service: 'Service | Services',
+    appliedSLA: 'Applied SLA',
+    appliedCondition: 'Applied condition',
+    reactionTime: 'Reaction time',
+    resolutionTime: 'Resolution time',
+    actualReactionTime: 'Actual reaction time',
+    actualResolutionTime: 'Actual resolution time',
+  },
   // describes Webitel FRONTEND applications + their navs
   WebitelApplications: {
     [WebitelApplications.AGENT]: { name: 'Agent Workspace' },
@@ -478,67 +498,121 @@ export default {
       filterLabel: ({ linked }) => {
         return linked('vocabulary.labels');
       },
-      agent: ({ linked }) => {
+      actualReactionTime: ({ linked }) => {
+        return linked('cases.actualReactionTime');
+      },
+      actualResolutionTime: ({ linked }) => {
+        return linked('cases.actualResolutionTime');
+      },
+      agent : ({ linked }) => {
         return linked('objects.agent.agent');
       },
-      amdResult: ({ linked }) => {
+      amdResult : ({ linked }) => {
         return linked('objects.amdResult');
       },
-      contact: ({ linked }) => {
+      assignee: ({ linked }) => {
+        return linked('cases.assignee');
+      },
+      author: ({ linked }) => {
+        return linked('cases.author');
+      },
+      cause : ({ linked }) => {
+        return linked('objects.hangupCause');
+      },
+      closeReasonGroupsCase: ({ linked }) => {
+        return linked('cases.reason');
+      },
+      contact : ({ linked }) => {
         return linked('vocabulary.contact');
       },
-      createdAtFrom: ({ linked }) => {
+      contactGroup: ({ linked }) => {
+        return linked('cases.group');
+      },
+      createdAtFrom : ({ linked }) => {
         return linked('reusable.from');
       },
-      createdAtTo: ({ linked }) => {
+      createdAtTo : ({ linked }) => {
         return linked('reusable.to');
       },
-      direction: ({ linked }) => {
-        return linked('objects.direction');
+      direction : ({ linked }) => {
+        return linked('calls.direction');
       },
-      rated: ({ linked }) => {
-        return linked('objects.evaluation');
-      },
-      gateway: ({ linked }) => {
-        return linked('objects.gateway');
+      gateway : ({ linked }) => {
+        return linked('vocabulary.gateway');
       },
-      grantee: ({ linked }) => {
+      grantee : ({ linked }) => {
         return linked('objects.grantee');
       },
-      cause: ({ linked }) => {
-        return linked('objects.hangupCause');
+      hasAttachment: ({ linked }) => {
+        return linked('objects.attachment');
+      },
+      hasFile: ({ linked }) => {
+        return linked('objects.hasRecording');
+      },
+      hasTranscription: ({ linked }) => {
+        return linked('objects.transcription');
       },
-      queue: ({ linked }) => {
+      impacted: ({ linked }) => {
+        return linked('cases.impacted');
+      },
+      priorityCase: ({ linked }) => {
+        return linked('vocabulary.priority');
+      },
+      queue : ({ linked }) => {
         return linked('objects.queue.queue');
       },
-      ratedBy: ({ linked }) => {
+      rated: ({ linked }) => {
+        return linked('objects.rated');
+      },
+      ratedBy : ({ linked }) => {
         return linked('objects.ratedBy');
       },
-      hasFile: ({ linked }) => {
-        return linked('objects.hasRecording');
+      rating: ({ linked }) => {
+        return linked('cases.rating');
+      },
+      reactionTime: ({ linked }) => {
+        return linked('cases.reactionTime');
+      },
+      reporter: ({ linked }) => {
+        return linked('cases.reporter');
+      },
+      resolutionTime: ({ linked }) => {
+        return linked('cases.resolutionTime');
       },
-      score: ({ linked }) => {
+      score : ({ linked }) => {
         return linked('webitelUI.auditForm.score');
       },
-      tags: ({ linked }) => {
+      serviceCase: ({ linked }) => {
+        return linked('cases.service');
+      },
+      sla: ({ linked }) => {
+        return linked('cases.appliedSLA');
+      },
+      slaCondition: ({ linked }) => {
+        return linked('cases.appliedCondition');
+      },
+      sourceCase: ({ linked }) => {
+        return linked('cases.source');
+      },
+      statusCase: ({ linked }) => {
+        return linked('cases.status');
+      },
+      tag : ({ linked }) => {
         return linked('vocabulary.tag');
       },
-      talkSec: ({ linked }) => {
+      talkDuration: ({ linked }) => {
         return linked('objects.talkDuration');
       },
-      team: ({ linked }) => {
+      team : ({ linked }) => {
         return linked('objects.team');
       },
-      duration: ({ linked }) => {
+      totalDuration: ({ linked }) => {
         return linked('objects.totalDuration');
       },
-      hasTranscription: ({ linked }) => {
-        return linked('objects.transcription');
-      },
-      user: ({ linked }) => {
+      user : ({ linked }) => {
         return linked('objects.user');
       },
-      variable: ({ linked }) => {
+      variable : ({ linked }) => {
         return linked('vocabulary.variables');
       },
     },