@webitel/api-services 0.0.23 → 0.0.25

package/src/api/clients/caseServiceCatalogs/serviceCatalogs.ts

@@ -0,0 +1,198 @@
+import { CatalogsApiFactory } 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 catalogsService = new CatalogsApiFactory(configuration, '', instance);
+
+const fieldsToSend = [
+  'id',
+  'name',
+  'code',
+  'sla',
+  'teams',
+  'skills',
+  'status',
+  'state',
+  'prefix',
+  'close_reason_group',
+  'reason',
+  'description',
+  'services',
+];
+const servicesFieldsToSend = [
+  'id',
+  'name',
+  'group',
+  'assignee',
+  'assignee.name',
+  'description',
+  'code',
+  'prefix',
+  'state',
+  'sla',
+  'root_id',
+  'catalog_id',
+];
+
+const getCatalogsList = async (params) => {
+  const fieldsToSend = [
+    'page',
+    'size',
+    'q',
+    'sort',
+    'fields',
+    'id',
+    'hasSubservices',
+  ];
+
+  const { page, size, fields, sort, id, q, has_subservices } = applyTransform(
+    params,
+    [
+      merge(getDefaultGetParams()),
+      starToSearch('search'),
+      (params) => ({ ...params, q: params.search }),
+      sanitize(fieldsToSend),
+      camelToSnake(),
+    ],
+  );
+  try {
+    const response = await catalogsService.listCatalogs(
+      page,
+      size,
+      [...fields, 'services'],
+      sort,
+      id,
+      q,
+      true,
+      '100', // Implemented depth 100 for load all subservices in one request
+      servicesFieldsToSend,
+      has_subservices,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, [snakeToCamel()]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getCatalog = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    return item.catalog;
+  };
+
+  try {
+    const response = await catalogsService.locateCatalog(
+      id,
+      fieldsToSend,
+      servicesFieldsToSend,
+    );
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addCatalog = async ({ itemInstance }) => {
+  const fieldsToSend = [
+    'name',
+    'description',
+    'prefix',
+    'code',
+    'state',
+    'sla',
+    'status',
+    'close_reason_group',
+    'teams',
+    'skills',
+  ];
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await catalogsService.createCatalog(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateCatalog = async ({ itemInstance, itemId: id }) => {
+  const fieldsToSend = [
+    'name',
+    'description',
+    'prefix',
+    'code',
+    'state',
+    'sla',
+    'status',
+    'close_reason_group',
+    'teams',
+    'skills',
+  ];
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await catalogsService.updateCatalog(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const patchCatalog = async ({ itemInstance, itemId: id }) => {
+  const fieldsToSend = ['name', 'description', 'state'];
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await catalogsService.updateCatalog2(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteCatalog = async ({ id }) => {
+  try {
+    const response = await catalogsService.deleteCatalog(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const ServiceCatalogsAPI = {
+  getList: getCatalogsList,
+  get: getCatalog,
+  add: addCatalog,
+  update: updateCatalog,
+  patch: patchCatalog,
+  delete: deleteCatalog,
+};
+
+export default ServiceCatalogsAPI;

package/src/api/clients/caseServices/services.ts

@@ -0,0 +1,181 @@
+import { ServicesApiFactory, WebitelContactsGroupType } 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 servicesService = new ServicesApiFactory(configuration, '', instance);
+
+const fieldsToSend = [
+  'name',
+  'code',
+  'sla',
+  'status',
+  'state',
+  'description',
+  'group',
+  'assignee',
+  'services',
+  'root_id',
+  'catalog_id',
+];
+
+const getServicesList = async ({ rootId, ...rest }) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const { page, size, fields, sort, id, q } = applyTransform(rest, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await servicesService.listServices(
+      page,
+      size,
+      sort,
+      id,
+      q,
+      rootId,
+      undefined,
+      fields,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, []),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getService = async ({ itemId: id }) => {
+  const fieldsToSend = [
+    'name',
+    'code',
+    'sla',
+    'state',
+    'prefix',
+    'group',
+    'assignee',
+    'description',
+    'catalog_id',
+    'root_id',
+  ];
+
+  const itemResponseHandler = (item) => {
+    return item.service;
+  };
+
+  try {
+    const response = await servicesService.locateService(id, fieldsToSend);
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const preRequestHandler = ({ rootId, catalogId }) => {
+  return (item) => ({
+    ...item,
+    assignee:
+      item.group?.type === WebitelContactsGroupType.DYNAMIC
+        ? {}
+        : item.assignee,
+    rootId,
+    catalogId,
+  });
+};
+
+const addService = async ({ itemInstance, rootId, catalogId }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler({ rootId, catalogId }),
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await servicesService.createService(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateService = async ({
+  itemInstance,
+  itemId: id,
+  rootId,
+  catalogId,
+}) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler({ rootId, catalogId }),
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await servicesService.updateService(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const patchService = async ({ changes, id }) => {
+  const body = applyTransform(changes, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await servicesService.updateService2(id, body);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteService = async ({ id }) => {
+  try {
+    const response = await servicesService.deleteService(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getServicesLookup = async (params) =>
+  getServicesList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const ServicesAPI = {
+  getList: getServicesList,
+  get: getService,
+  add: addService,
+  update: updateService,
+  patch: patchService,
+  delete: deleteService,
+  getLookup: getServicesLookup,
+};
+
+export default ServicesAPI;

package/src/api/clients/caseSources/caseSources.ts

@@ -0,0 +1,121 @@
+import {
+  createSourceBody,
+  getSources,
+  listSourcesQueryParams,
+  updateSourceBody,
+} from '@webitel/api-services/gen';
+import {
+  getFieldsToSendFromZodSchema,
+  getShallowFieldsToSendFromZodSchema,
+} from '@webitel/api-services/gen/utils';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+} from '../../transformers/index';
+
+const sourceService = getSources();
+
+const getSourcesList = async (params) => {
+  const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+    listSourcesQueryParams,
+  );
+
+  const { page, size, fields, sort, id, q, type } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+
+  try {
+    const response = await sourceService.listSources({
+      page,
+      size,
+      fields,
+      sort,
+      id,
+      q: q || params.search,
+      type,
+    });
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, []),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getSource = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => item.source; // TODO wtf??
+
+  try {
+    const response = await sourceService.locateSource(id);
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addSource = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(getShallowFieldsToSendFromZodSchema(createSourceBody)),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await sourceService.createSource(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateSource = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(getShallowFieldsToSendFromZodSchema(updateSourceBody)),
+  ]);
+
+  try {
+    const response = await sourceService.updateSource(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteSource = async ({ id }) => {
+  try {
+    const response = await sourceService.deleteSource(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getLookup = (params) =>
+  getSourcesList({
+    ...params,
+    fields: params.fields || ['id', 'name', 'type'],
+  });
+
+const CaseSourcesAPI = {
+  getList: getSourcesList,
+  get: getSource,
+  add: addSource,
+  update: updateSource,
+  delete: deleteSource,
+  getLookup,
+};
+
+export default CaseSourcesAPI;

package/src/api/clients/caseStatusConditions/caseStatusConditions.ts

@@ -0,0 +1,165 @@
+import { StatusConditionsApiFactory } from 'webitel-sdk';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  merge,
+  notify,
+  sanitize,
+  snakeToCamel,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const statusConditionsService = new StatusConditionsApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const fieldsToSend = ['name', 'description'];
+
+const getStatusConditionsList = async ({ parentId, ...rest }) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const { page, size, fields, sort, id, q } = applyTransform(rest, [
+    merge(getDefaultGetParams()),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+
+  try {
+    const response = await statusConditionsService.listStatusConditions(
+      parentId,
+      page,
+      size,
+      fields,
+      sort,
+      id,
+      q,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, [snakeToCamel()]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getStatusCondition = async ({ parentId, itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    return item.status;
+  };
+
+  try {
+    const response = await statusConditionsService.locateStatusCondition(
+      parentId,
+      id,
+      fieldsToSend,
+    );
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateStatusCondition = async ({
+  itemInstance,
+  itemId: id,
+  parentId,
+}) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await statusConditionsService.updateStatusCondition(
+      parentId,
+      id,
+      item,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addStatusCondition = async ({ itemInstance, parentId }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await statusConditionsService.createStatusCondition(
+      parentId,
+      item,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const patchStatusCondition = async ({ id, parentId, changes }) => {
+  const fieldsToSend = ['name', 'description', 'initial', 'final'];
+  const input = applyTransform(changes, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await statusConditionsService.updateStatusCondition2(
+      parentId,
+      id,
+      input,
+    );
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteStatusCondition = async ({ id, parentId }) => {
+  try {
+    const response = await statusConditionsService.deleteStatusCondition(
+      parentId,
+      id,
+    );
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getStatusesLookup = (params) =>
+  getStatusConditionsList({
+    ...params,
+    parentId: params.parentId,
+    id: params.id,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const CaseStatusConditionsAPI = {
+  getList: getStatusConditionsList,
+  getLookup: getStatusesLookup,
+  get: getStatusCondition,
+  update: updateStatusCondition,
+  patch: patchStatusCondition,
+  delete: deleteStatusCondition,
+  add: addStatusCondition,
+};
+
+export default CaseStatusConditionsAPI;