@webitel/api-services 0.0.25 → 0.0.27

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

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

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

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

@@ -1,64 +1,60 @@
 import {
-  getDefaultGetListResponse,
-  getDefaultGetParams,
-  getDefaultInstance,
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
 } from '../../../defaults';
 import applyTransform, {
-  camelToSnake,
-  generateUrl,
-  merge,
-  notify,
-  sanitize,
-  starToSearch,
+	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 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,
+	getSysTypeRecordsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const SysTypesAPI = {
+	getList: getSysTypeRecordsList,
+	getLookup: getSysTypeRecordsLookup,
 };
-
-export { getSysTypeRecordsList, getSysTypeRecordsLookup };
-
-export default SysTypesApi;