@webitel/api-services 0.0.24 → 0.0.25

package/src/api/clients/calendars/calendars.ts

@@ -0,0 +1,214 @@
+import deepCopy from 'deep-copy';
+import { CalendarServiceApiFactory } 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 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: [],
+    };
+
+    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) {
+      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;

package/src/api/clients/caseCloseReasonGroups/caseCloseReasonGroups.ts

@@ -0,0 +1,128 @@
+import { CloseReasonGroupsApiFactory } 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 closeReasonGroupsService = new CloseReasonGroupsApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const fieldsToSend = ['name', 'description'];
+
+const getCloseReasonGroupsList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const { page, size, fields, sort, id, q } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await closeReasonGroupsService.listCloseReasonGroups(
+      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 getCloseReasonGroups = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    return item.closeReasonGroup;
+  };
+
+  try {
+    const response = await closeReasonGroupsService.locateCloseReasonGroup(
+      id,
+      fieldsToSend,
+    );
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addCloseReasonGroups = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response =
+      await closeReasonGroupsService.createCloseReasonGroup(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateCloseReasonGroups = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await closeReasonGroupsService.updateCloseReasonGroup(
+      id,
+      item,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteCloseReasonGroups = async ({ id }) => {
+  try {
+    const response = await closeReasonGroupsService.deleteCloseReasonGroup(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getCloseReasonGroupsLookup = async (params) =>
+  getCloseReasonGroupsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const CaseCloseReasonGroupsAPI = {
+  getList: getCloseReasonGroupsList,
+  get: getCloseReasonGroups,
+  add: addCloseReasonGroups,
+  update: updateCloseReasonGroups,
+  delete: deleteCloseReasonGroups,
+  getLookup: getCloseReasonGroupsLookup,
+};
+
+export default CaseCloseReasonGroupsAPI;

package/src/api/clients/caseCloseReasons/caseCloseReasons.ts

@@ -0,0 +1,128 @@
+import { CloseReasonsApiFactory } 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 closeReasonsService = new CloseReasonsApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const fieldsToSend = ['name', 'description'];
+
+const getCloseReasonsList = 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 closeReasonsService.listCloseReasons(
+      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 getCloseReason = async ({ parentId, itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    return item.closeReason;
+  };
+
+  try {
+    const response = await closeReasonsService.locateCloseReason(parentId, id);
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addCloseReason = async ({ itemInstance, parentId }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await closeReasonsService.createCloseReason(
+      parentId,
+      item,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateCloseReason = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [camelToSnake()]);
+
+  try {
+    const response = await closeReasonsService.updateCloseReason(
+      itemInstance.id,
+      id,
+      item,
+    );
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteCloseReason = async ({ id, parentId }) => {
+  try {
+    const response = await closeReasonsService.deleteCloseReason(parentId, id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getCloseReasonLookup = async (params) =>
+  getCloseReasonsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const CaseCloseReasonsAPI = {
+  getList: getCloseReasonsList,
+  getLookup: getCloseReasonLookup,
+  get: getCloseReason,
+  add: addCloseReason,
+  update: updateCloseReason,
+  delete: deleteCloseReason,
+};
+
+export default CaseCloseReasonsAPI;

package/src/api/clients/casePriorities/casePriorities.ts

@@ -0,0 +1,139 @@
+import { PrioritiesApiFactory } 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 priorityService = new PrioritiesApiFactory(configuration, '', instance);
+
+const fieldsToSend = ['name', 'description', 'color'];
+
+const getPrioritiesList = async (params) => {
+  const fieldsToSend = [
+    'page',
+    'size',
+    'q',
+    'sort',
+    'fields',
+    'id',
+    'notInSla',
+    'inSla',
+    'inSlaCond',
+  ];
+  const {
+    page,
+    size,
+    fields,
+    sort,
+    id,
+    q,
+    not_in_sla: notInSla,
+    in_sla_cond: inSlaCond,
+  } = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await priorityService.listPriorities(
+      page,
+      size,
+      fields,
+      sort,
+      id,
+      q,
+      notInSla,
+      inSlaCond,
+    );
+    const { items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, []),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getPriority = async ({ itemId: id }) => {
+  const itemResponseHandler = (item) => {
+    return item.priority;
+  };
+
+  try {
+    const response = await priorityService.locatePriority(id, fieldsToSend);
+    return applyTransform(response.data, [snakeToCamel(), itemResponseHandler]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addPriority = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await priorityService.createPriority(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updatePriority = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+
+  try {
+    const response = await priorityService.updatePriority(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deletePriority = async ({ id }) => {
+  try {
+    const response = await priorityService.deletePriority(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getConditionsLookup = (params) =>
+  getPrioritiesList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const CasePrioritiesAPI = {
+  getList: getPrioritiesList,
+  get: getPriority,
+  update: updatePriority,
+  getLookup: getConditionsLookup,
+  delete: deletePriority,
+  add: addPriority,
+};
+
+export default CasePrioritiesAPI;