@webitel/api-services 0.0.23 → 0.0.25

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

@@ -0,0 +1,230 @@
+import deepCopy from 'deep-copy';
+
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  mergeEach,
+  notify,
+  sanitize,
+  snakeToCamel,
+} from '../../transformers/index';
+import { generatePermissionsApi } from '../_shared/generatePermissionsApi';
+
+const instance = getDefaultInstance();
+
+const baseUrl = '/users';
+const fieldsToSend = [
+  'name',
+  'username',
+  'password',
+  'extension',
+  'status',
+  'note',
+  'roles',
+  'license',
+  'devices',
+  'device',
+  'profile',
+  'email',
+  'contact',
+  'chatName',
+];
+
+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()),
+    (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) => {
+        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;
+
+  if (copy.roles) copy.roles.forEach((copy) => delete copy.text);
+
+  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,
+
+  ...generatePermissionsApi(baseUrl),
+};
+
+export default UsersAPI;

package/src/api/clients/wtTypes/_shared/utils/sortDynamicFields.ts

@@ -0,0 +1,21 @@
+import deepCopy from 'deep-copy';
+import { WebitelProtoDataStruct } from 'webitel-sdk';
+
+export const sortDynamicFields = (
+  item: WebitelProtoDataStruct,
+): WebitelProtoDataStruct => {
+  const unSortableFields = item.fields.filter((field) => !field.position);
+
+  const sortableFields = deepCopy(item.fields)
+    .filter((field) => field.position)
+    .sort((a, b) => {
+      return a.position - b.position;
+    });
+
+  const fields = [...unSortableFields, ...sortableFields];
+
+  return {
+    ...item,
+    fields,
+  };
+};

package/src/api/clients/wtTypes/sysTypes/sysTypes.ts

@@ -0,0 +1,64 @@
+import {
+  getDefaultGetListResponse,
+  getDefaultGetParams,
+  getDefaultInstance,
+} from '../../../defaults';
+import applyTransform, {
+  camelToSnake,
+  generateUrl,
+  merge,
+  notify,
+  sanitize,
+  starToSearch,
+} from '../../../transformers';
+
+const instance = getDefaultInstance();
+
+const getSysTypeRecordsList = async ({ path, display, primary, ...params }) => {
+  const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id', 'ids'];
+
+  const url = applyTransform(params, [
+    merge(getDefaultGetParams()),
+    starToSearch('search'),
+    (params) => ({ ...params, q: params.search }),
+    (params) => ({
+      ...params,
+      ids: params.id /* https://webitel.atlassian.net/browse/WTEL-6788 */,
+    }),
+    sanitize(fieldsToSend),
+    camelToSnake(),
+    generateUrl(path),
+  ]);
+  try {
+    const response = await instance.get(url);
+    const { data, items, next } = applyTransform(response.data, [
+      merge(getDefaultGetListResponse()),
+    ]);
+
+    return {
+      // Some endpoints return data, some return items so we need to check for both of them
+      items:
+        applyTransform(data || items, [
+          // transformItemsForSelect({ display, primary }),
+        ]) ?? [],
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const getSysTypeRecordsLookup = (params) =>
+  getSysTypeRecordsList({
+    ...params,
+    fields: params.fields || ['id', 'name'],
+  });
+
+const SysTypesApi = {
+  getList: getSysTypeRecordsList,
+  getLookup: getSysTypeRecordsLookup,
+};
+
+export { getSysTypeRecordsList, getSysTypeRecordsLookup };
+
+export default SysTypesApi;

package/src/api/clients/wtTypes/typeExtensions/typeExtensions.ts

@@ -0,0 +1,122 @@
+import { ExtensionsApiFactory, WebitelProtoDataStruct } from 'webitel-sdk';
+
+import { getDefaultInstance, getDefaultOpenAPIConfig } from '../../../defaults';
+import applyTransform, {
+  camelToSnake,
+  notify,
+  sanitize,
+  snakeToCamel,
+} from '../../../transformers';
+import { sortDynamicFields } from '../_shared/utils/sortDynamicFields';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const typeExtensionsService = ExtensionsApiFactory(configuration, '', instance);
+
+const fieldsToSend = ['fields', 'repo', 'path'];
+
+const generateIdsFromRepos = (item: WebitelProtoDataStruct) => ({
+  ...item,
+  id: item.repo,
+});
+
+const getTypeExtension = async ({ itemId: typeRepo }) => {
+  const createPositionGenerator = () => {
+    let position = 1;
+    return (item) => (item.readonly ? null : position++);
+  };
+  const getPosition = createPositionGenerator();
+
+  const itemResponseHandler = (item) => ({
+    ...item,
+    fields: item.fields.map((field) => ({
+      ...field,
+      position: getPosition(field),
+    })),
+  });
+
+  try {
+    const response = await typeExtensionsService.locateType(typeRepo);
+
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      generateIdsFromRepos,
+      itemResponseHandler,
+    ]);
+  } catch {
+    return {
+      id: typeRepo,
+      fields: [],
+      isNew: true,
+    };
+  }
+};
+
+const addTypeExtension = async ({ itemInstance, itemId: typeRepo }) => {
+  const item = applyTransform(itemInstance, [
+    sortDynamicFields,
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await typeExtensionsService.createType(typeRepo, item);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      generateIdsFromRepos,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const deleteTypeExtension = async ({ itemId: typeRepo }) => {
+  try {
+    await typeExtensionsService.deleteType(typeRepo);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const updateTypeExtension = async ({ itemInstance, itemId: typeRepo }) => {
+  if (!itemInstance.fields.length && itemInstance.isNew) {
+    return itemInstance;
+  } else if (itemInstance.isNew) {
+    return addTypeExtension({ itemInstance, itemId: typeRepo });
+  }
+
+  if (!itemInstance.fields.length && !itemInstance.isNew) {
+    return deleteTypeExtension({ itemId: typeRepo });
+  }
+
+  const item = applyTransform(itemInstance, [
+    sortDynamicFields,
+    camelToSnake(),
+    sanitize(fieldsToSend),
+  ]);
+  try {
+    const response = await typeExtensionsService.updateType(typeRepo, item);
+    return applyTransform(response.data, [
+      snakeToCamel(),
+      generateIdsFromRepos,
+    ]);
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+const WtTypeExtensionApi = {
+  getList: getTypeExtension,
+  add: addTypeExtension,
+  update: updateTypeExtension,
+  delete: deleteTypeExtension,
+};
+
+export {
+  addTypeExtension,
+  deleteTypeExtension,
+  getTypeExtension,
+  updateTypeExtension,
+};
+
+export default WtTypeExtensionApi;

package/src/api/clients//321/201ontacts/contactChatMessagesHistory.ts

@@ -0,0 +1,98 @@
+import { ContactsChatCatalogApiFactory } from 'webitel-sdk';
+
+import i18n from '../../../locale/i18n';
+import {
+  getDefaultGetListResponse,
+  getDefaultInstance,
+  getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+  merge,
+  notify,
+  snakeToCamel,
+} from '../../transformers/index';
+
+const { t } = i18n.global;
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const contactChatService = new ContactsChatCatalogApiFactory(
+  configuration,
+  '',
+  instance,
+);
+
+const getChat = async ({ contactId, chatId }) => {
+  const mergeChatMessagesData = ({ messages, peers }) => {
+    if (!messages) return [];
+    return messages.map(({ from, ...message }) => {
+      return {
+        ...message,
+        peer: peers[from.id - 1],
+      };
+    });
+  };
+
+  try {
+    const response = await contactChatService.getContactChatHistory(
+      contactId,
+      chatId,
+    );
+    const { messages, peers } = applyTransform(response.data, [snakeToCamel()]);
+    return {
+      items: applyTransform({ messages, peers }, [mergeChatMessagesData]),
+      peers,
+    };
+  } catch (err) {
+    throw applyTransform(err, [notify]);
+  }
+};
+
+// all messages from all contacts chats
+const getAllMessages = async (params) => {
+  const mergeMessagesData = ({ messages, peers, chats }) => {
+    if (!messages) return [];
+    return messages.map(({ from, chat, ...message }) => {
+      return {
+        ...message,
+        peer: peers[from.id - 1],
+        chat: chats[chat.id - 1],
+      };
+    });
+  };
+
+  const { contactId, page, size } = params;
+
+  try {
+    const response = await contactChatService.getContactChatHistory2(
+      contactId,
+      undefined,
+      undefined,
+      size,
+      `${page || 1}`,
+    );
+    const { messages, peers, chats, next } = applyTransform(response.data, [
+      snakeToCamel(),
+      merge(getDefaultGetListResponse()),
+    ]);
+    return {
+      items: applyTransform({ messages, peers, chats }, [mergeMessagesData]),
+      next,
+    };
+  } catch (err) {
+    throw applyTransform(err, [
+      notify(({ callback }) =>
+        callback({
+          type: 'error',
+          text: t('errorNotifications.chatHistoryApi'),
+        }),
+      ),
+    ]);
+  }
+};
+
+export default {
+  getChat,
+  getAllMessages,
+};