@webitel/api-services 0.0.23 → 0.0.25

package/src/api/clients/slaConditions/slaConditions.ts

@@ -0,0 +1,165 @@
+import { SLAConditionsApiFactory } 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 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()),
+    (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.ts

@@ -0,0 +1,118 @@
+import { SLAsApiFactory } 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 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()),
+    (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/api/clients/teams/teams.ts

@@ -0,0 +1,144 @@
+import { AgentTeamServiceApiFactory } 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 teamService = new AgentTeamServiceApiFactory(configuration, '', instance);
+
+const fieldsToSend = [
+  'name',
+  'description',
+  'strategy',
+  'admin',
+  'maxNoAnswer',
+  'wrapUpTime',
+  'noAnswerDelayTime',
+  'taskAcceptTimeout',
+  'callTimeout',
+  'inviteChatTimeout',
+];
+
+const getTeamsList = async (params) => {
+  const { page, size, search, sort, fields, id, strategy, adminId } =
+    applyTransform(params, [
+      merge(getDefaultGetParams()),
+      starToSearch('search'),
+    ]);
+
+  try {
+    const response = await teamService.searchAgentTeam(
+      page,
+      size,
+      search,
+      sort,
+      fields,
+      id,
+      strategy,
+      adminId,
+    );
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items,
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getTeam = async ({ itemId: id }) => {
+  const defaultObject = {
+    name: '',
+    strategy: {},
+    admin: [],
+    description: '',
+    busyDelayTime: 0,
+    callTimeout: 0,
+    maxNoAnswer: 0,
+    noAnswerDelayTime: 0,
+    taskAcceptTimeout: 0,
+    inviteChatTimeout: 0,
+    rejectDelayTime: 0,
+    wrapUpTime: 0,
+  };
+
+  try {
+    const response = await teamService.readAgentTeam(id);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      merge(defaultObject),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const addTeam = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await teamService.createAgentTeam(item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateTeam = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    sanitize(fieldsToSend),
+    camelToSnake(),
+  ]);
+  try {
+    const response = await teamService.updateAgentTeam(id, item);
+    return applyTransform(response.data, [snakeToCamel()]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteTeam = async ({ id }) => {
+  try {
+    const response = await teamService.deleteAgentTeam(id);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getTeamsLookup = (params) =>
+  getTeamsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const TeamsAPI = {
+  getList: getTeamsList,
+  get: getTeam,
+  add: addTeam,
+  update: updateTeam,
+  delete: deleteTeam,
+  getLookup: getTeamsLookup,
+};
+
+export default TeamsAPI;

package/src/api/clients/users/__tests__/users.spec.ts

@@ -0,0 +1,265 @@
+import axiosMock from '../../../../tests/mocks/axiosMock';
+
+const instanceMock = axiosMock()().default;
+
+vi.doMock('../../../defaults/getDefaultInstance/getDefaultInstance.ts', () => ({
+  default: () => instanceMock,
+}));
+
+describe('UsersAPI', () => {
+  beforeEach(() => {
+    Object.assign(instanceMock, axiosMock()().default);
+  });
+
+  it('correctly computes "getList" method api call', async () => {
+    const get = vi.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    );
+
+    instanceMock.get = get;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    const inputParams = {
+      fields: ['id', 'name', 'vitest'],
+    };
+    const url = '/users?fields=id&fields=name&fields=vitest&page=1&size=10';
+    await UsersAPI.getList(inputParams);
+    expect(get).toHaveBeenCalledWith(url);
+  });
+
+  it('correctly computes "getList" method output', async () => {
+    const output = {
+      items: [
+        {
+          dnd: false,
+          id: 1,
+          name: '',
+          state: true,
+          status: '',
+          shouldCaseConvert: '',
+        },
+      ],
+      next: true,
+    };
+
+    const response = {
+      data: {
+        items: [{ id: 1, should_case_convert: '' }],
+        next: true,
+      },
+    };
+
+    const get = vi.fn(() => Promise.resolve(response));
+
+    instanceMock.get = get;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    expect(await UsersAPI.getList({})).toEqual(output);
+  });
+
+  it('correctly computes "get" method api call', async () => {
+    const inputParams = {
+      itemId: 1,
+    };
+    const url = '/users/1';
+
+    const get = vi.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    );
+
+    instanceMock.get = get;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    await UsersAPI.get(inputParams);
+    expect(get).toHaveBeenCalledWith(url);
+  });
+
+  it('correctly computes "get" method output', async () => {
+    const output = {
+      id: 1,
+      device: {},
+      devices: [],
+      license: [],
+      roles: [],
+      variables: [
+        {
+          key: '',
+          value: '',
+        },
+      ],
+    };
+
+    const response = {
+      data: {
+        id: 1,
+      },
+    };
+
+    const get = vi.fn(() => Promise.resolve(response));
+
+    instanceMock.get = get;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    expect(await UsersAPI.get({})).toEqual(output);
+  });
+
+  it('correctly computes "add" method api call', async () => {
+    const input = {
+      itemInstance: {
+        name: 'test',
+      },
+    };
+
+    const body = {
+      name: 'test',
+      profile: {}, // variables field (?)
+    };
+
+    const url = '/users';
+
+    const post = vi.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    );
+
+    instanceMock.post = post;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    await UsersAPI.add(input);
+    expect(post).toHaveBeenCalledWith(url, body);
+  });
+
+  it('correctly computes "add" method output', async () => {
+    const output = {
+      id: 1,
+      checkCase: '',
+    };
+
+    const response = {
+      data: {
+        id: 1,
+        check_case: '',
+      },
+    };
+
+    const post = vi.fn(() => Promise.resolve(response));
+
+    instanceMock.post = post;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    expect(await UsersAPI.add({ itemInstance: {} })).toEqual(output);
+  });
+
+  it('correctly computes "update" method api call', async () => {
+    const input = {
+      itemInstance: {
+        name: 'test',
+      },
+      itemId: 1,
+    };
+
+    const body = {
+      name: 'test',
+      profile: {}, // variables field (?)
+    };
+
+    const url = '/users/1';
+
+    const put = vi.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    );
+
+    instanceMock.put = put;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    await UsersAPI.update(input);
+    expect(put).toHaveBeenCalledWith(url, body);
+  });
+
+  it('correctly computes "update" method output', async () => {
+    const output = {
+      id: 1,
+      checkCase: '',
+    };
+
+    const response = {
+      data: {
+        id: 1,
+        check_case: '',
+      },
+    };
+
+    const put = vi.fn(() => Promise.resolve(response));
+
+    instanceMock.put = put;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    expect(await UsersAPI.update({ itemInstance: {}, itemId: 1 })).toEqual(
+      output,
+    );
+  });
+
+  it('correctly computes "patch" method api call', async () => {
+    const input = {
+      changes: {
+        name: 'test',
+      },
+      id: 1,
+    };
+
+    const body = {
+      name: 'test',
+    };
+
+    const url = '/users/1';
+
+    const patch = vi.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    );
+
+    instanceMock.patch = patch;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    await UsersAPI.patch(input);
+    expect(patch).toHaveBeenCalledWith(url, body);
+  });
+
+  it('correctly computes "delete" method api call', async () => {
+    const input = {
+      id: 1,
+    };
+
+    const url = '/users/1?permanent=true';
+
+    const _delete = vi.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    );
+
+    instanceMock.delete = _delete;
+
+    const UsersAPI = (await import('../users.ts')).default;
+
+    await UsersAPI.delete(input);
+    expect(_delete).toHaveBeenCalledWith(url);
+  });
+});