@webitel/ui-sdk 24.4.19 → 24.4.21

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

@@ -0,0 +1,200 @@
+import axios from 'axios';
+import UsersAPI from '../users';
+
+// axios mock should be copy-pasted :(
+// https://stackoverflow.com/questions/65554910/jest-referenceerror-cannot-access-before-initialization
+vi.mock('axios', () => {
+  return {
+    default: {
+      post: vi.fn(),
+      get: vi.fn(),
+      delete: vi.fn(),
+      put: vi.fn(),
+      patch: vi.fn(),
+      create: vi.fn().mockReturnThis(),
+      interceptors: {
+        request: {
+          use: vi.fn(), eject: vi.fn(),
+        }, response: {
+          use: vi.fn(), eject: vi.fn(),
+        },
+      },
+    },
+  };
+});
+
+describe('UsersAPI', () => {
+  it('correctly computes "getList" method api call', async () => {
+    const inputParams = {
+      fields: ['id', 'name', 'vitest'],
+    };
+    const url = '/users?fields=id&fields=name&fields=vitest&page=1&size=10';
+    const mock = axios.get.mockImplementationOnce(() => Promise.resolve({
+      data: {},
+    }));
+    await UsersAPI.getList(inputParams);
+    expect(mock).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,
+      },
+    };
+    axios.get.mockImplementationOnce(() => Promise.resolve(response));
+    expect(await UsersAPI.getList({})).toEqual(output);
+  });
+
+  it('correctly computes "get" method api call', async () => {
+    const inputParams = {
+      itemId: 1,
+    };
+    const url = '/users/1';
+    const mock = axios.get.mockImplementationOnce(() => Promise.resolve({
+      data: {},
+    }));
+    await UsersAPI.get(inputParams);
+    expect(mock).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,
+      },
+    };
+    axios.get.mockImplementationOnce(() => Promise.resolve(response));
+    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 mock = axios.post.mockImplementationOnce(() => Promise.resolve({
+      data: {},
+    }));
+    await UsersAPI.add(input);
+    expect(mock).toHaveBeenCalledWith(url, body);
+  });
+
+  it('correctly computes "add" method output', async () => {
+    const output = {
+      id: 1,
+      checkCase: '',
+    };
+
+    const response = {
+      data: {
+        id: 1,
+        check_case: '',
+      },
+    };
+    axios.post.mockImplementationOnce(() => Promise.resolve(response));
+    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 mock = axios.put.mockImplementationOnce(() => Promise.resolve({
+      data: {},
+    }));
+    await UsersAPI.update(input);
+    expect(mock).toHaveBeenCalledWith(url, body);
+  });
+
+  it('correctly computes "update" method output', async () => {
+    const output = {
+      id: 1,
+      checkCase: '',
+    };
+
+    const response = {
+      data: {
+        id: 1,
+        check_case: '',
+      },
+    };
+    axios.put.mockImplementationOnce(() => Promise.resolve(response));
+    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 mock = axios.patch.mockImplementationOnce(() => Promise.resolve({
+      data: {},
+    }));
+    await UsersAPI.patch(input);
+    expect(mock).toHaveBeenCalledWith(url, body);
+  });
+
+  it('correctly computes "delete" method api call', async () => {
+    const input = {
+      id: 1,
+    };
+
+    const url = '/users/1?permanent=true';
+    const mock = axios.delete.mockImplementationOnce(() => Promise.resolve({
+      data: {},
+    }));
+    await UsersAPI.delete(input);
+    expect(mock).toHaveBeenCalledWith(url);
+  });
+});

package/src/api/clients/users/users.js

@@ -0,0 +1,254 @@
+import deepCopy from 'deep-copy';
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams, getDefaultInstance,
+} from '../../defaults';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+  starToSearch,
+} from '../../transformers';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/users';
+const fieldsToSend = [
+  'name',
+  'username',
+  'password',
+  'extension',
+  'status',
+  'note',
+  'roles',
+  'license',
+  'devices',
+  'device',
+  'profile',
+  'email',
+];
+
+const getUsersList = async (params) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+  const defaultObject = {
+    name: '',
+    status: '',
+    state: true,
+    dnd: false,
+  };
+
+  const url = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+    generateUrl(baseUrl),
+  ]);
+  try {
+    const response = await instance.get(url);
+    const { items, next } = applyTransform(response.data, [
+      snakeToCamel(['profile']),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform(items, [
+        mergeEach(defaultObject),
+      ]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const getUser = async ({ itemId: id }) => {
+  const defaultObject = {
+    roles: [],
+    license: [],
+    devices: [],
+    device: {},
+    variables: [
+      { key: '', value: '' },
+    ],
+  };
+
+  const itemResponseHandler = (item) => {
+    const copy = deepCopy(item);
+    if (copy.license) {
+      copy.license.forEach((item) => {
+        // eslint-disable-next-line no-param-reassign
+        item.name = item.prod;
+      });
+    }
+    if (copy.profile) {
+      copy.variables = Object.keys(copy.profile).map((key) => ({
+        key,
+        value: copy.profile[key],
+      }));
+    } else {
+      copy.variables = [{ key: '', value: '' }];
+    }
+    return copy;
+  };
+
+  const url = `${baseUrl}/${id}`;
+
+  try {
+    const response = await instance.get(url);
+    return applyTransform(response.data, [
+      snakeToCamel(['profile']),
+      merge(defaultObject),
+      itemResponseHandler,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const preRequestHandler = (item) => {
+  const copy = deepCopy(item);
+  if (item.device && !item.device.id) delete copy.device;
+  // eslint-disable-next-line no-param-reassign
+  if (copy.roles) copy.roles.forEach((copy) => delete copy.text);
+  // eslint-disable-next-line no-param-reassign
+  if (copy.devices) copy.devices.forEach((copy) => delete copy.text);
+  if (copy.license) {
+    copy.license = copy.license.map((copy) => ({ id: copy.id }));
+  }
+  copy.profile = {};
+  if (copy.variables) {
+    copy.variables.forEach((variable) => {
+      copy.profile[variable.key] = variable.value;
+    });
+  }
+  return copy;
+};
+
+const addUser = async ({ itemInstance }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    camelToSnake(['profile']),
+  ]);
+  try {
+    const response = await instance.post(baseUrl, item);
+    return applyTransform(response.data, [
+      snakeToCamel(['profile']),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const updateUser = async ({ itemInstance, itemId: id }) => {
+  const item = applyTransform(itemInstance, [
+    preRequestHandler,
+    sanitize(fieldsToSend),
+    camelToSnake(['profile']),
+  ]);
+
+  const url = `${baseUrl}/${id}`;
+  try {
+    const response = await instance.put(url, item);
+    return applyTransform(response.data, [
+      snakeToCamel(['profile']),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const patchUser = async ({ changes, id }) => {
+  const body = applyTransform(changes, [
+    sanitize(fieldsToSend),
+    camelToSnake(['profile']),
+  ]);
+  const url = `${baseUrl}/${id}`;
+  try {
+    const response = await instance.patch(url, body);
+    return applyTransform(response.data, [
+      snakeToCamel(['profile']),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const patchUserPresence = async ({ changes, id }) => {
+  const body = applyTransform(changes, [
+    sanitize(fieldsToSend),
+    camelToSnake(['profile']),
+  ]);
+  const url = `${baseUrl}/${id}/presence`;
+  try {
+    const response = await instance.patch(url, body);
+    return applyTransform(response.data, [
+      snakeToCamel(['profile']),
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const deleteUser = async ({ id }) => {
+  const url = `${baseUrl}/${id}?permanent=true`;
+  // permanent=true for complete deletion
+  try {
+    const response = await instance.delete(url);
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [
+      notify,
+    ]);
+  }
+};
+
+const getUsersLookup = (params) => getUsersList({
+  ...params,
+  fields: params.fields || ['id', 'name'],
+});
+
+const logoutUser = async ({ id }) => {
+  const url = `${baseUrl}/${id}/logout`;
+  try {
+    const response = await instance.post(url, {});
+    return applyTransform(response.data, []);
+  } catch (err) {
+    throw applyTransform(err, [
+
+      notify,
+    ]);
+  }
+};
+
+const UsersAPI = {
+  getList: getUsersList,
+  get: getUser,
+  add: addUser,
+  patch: patchUser,
+  update: updateUser,
+  delete: deleteUser,
+  getLookup: getUsersLookup,
+  patchUserPresence,
+  logoutUser,
+};
+
+export default UsersAPI;

package/src/api/defaults/getDefaultInstance/getDefaultInstance.js

@@ -0,0 +1,14 @@
+import generateInstance from '../../axios/generateInstance';
+import updateTokenInterceptor
+  from '../../interceptors/request/updateToken.interceptor';
+import handleUnauthorizedInterceptor
+  from '../../interceptors/response/handleUnauthorized.interceptor';
+
+const getDefaultInstance = () => generateInstance({
+  interceptors: {
+    request: [updateTokenInterceptor],
+    response: [handleUnauthorizedInterceptor],
+  },
+});
+
+export default getDefaultInstance;

package/src/api/defaults/getDefaultOpenAPIConfig/getDefaultOpenAPIConfig.js

@@ -0,0 +1,9 @@
+import { Configuration } from 'webitel-sdk';
+
+const getDefaultOpenAPIConfig = () => new Configuration({
+  basePath: import.meta.env.VITE_API_URL,
+  apiKey: localStorage.getItem('access-key') || '',
+  accessToken: localStorage.getItem('access-key') || '',
+});
+
+export default getDefaultOpenAPIConfig;

package/src/api/defaults/index.js

@@ -1,7 +1,11 @@
 import getDefaultGetParams from './getDefaultGetParams/getDefaultGetParams';
 import getDefaultGetListResponse from './getDefaultGetListResponse/getDefaultGetListResponse';
+import getDefaultInstance from './getDefaultInstance/getDefaultInstance';
+import getDefaultOpenAPIConfig from './getDefaultOpenAPIConfig/getDefaultOpenAPIConfig';
 
 export {
   getDefaultGetParams,
   getDefaultGetListResponse,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
 };

package/src/enums/ChatGatewayProvider/ChatGatewayProvider.enum.js

@@ -5,6 +5,7 @@ const ChatGatewayProvider = Object.freeze({
   VIBER: 'viber',
   WEBCHAT: 'webchat',
   INFOBIP: 'infobip_whatsapp',
+  CUSTOM: 'custom',
 });
 
 export default ChatGatewayProvider;