@northern.tech/store 0.1.0

package/utils.test.ts

@@ -0,0 +1,187 @@
+// Copyright 2019 Northern.tech AS
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// @ts-nocheck
+import { defaultState, token } from '../../../tests/mockData';
+import { DARK_MODE, LIGHT_MODE } from './constants';
+import {
+  generateDeploymentGroupDetails,
+  groupDeploymentDevicesStats,
+  groupDeploymentStats,
+  isDarkMode,
+  mapDeviceAttributes,
+  preformatWithRequestID
+} from './utils';
+
+describe('mapDeviceAttributes function', () => {
+  const defaultAttributes = {
+    inventory: { device_type: [], artifact_name: '' },
+    identity: {},
+    monitor: {},
+    system: {},
+    tags: {}
+  };
+  it('works with empty attributes', async () => {
+    expect(mapDeviceAttributes()).toEqual(defaultAttributes);
+    expect(mapDeviceAttributes([])).toEqual(defaultAttributes);
+  });
+  it('handles unscoped attributes', async () => {
+    const testAttributesObject1 = { name: 'this1', value: 'that1' };
+    expect(mapDeviceAttributes([testAttributesObject1])).toEqual({
+      ...defaultAttributes,
+      inventory: {
+        ...defaultAttributes.inventory,
+        this1: 'that1'
+      }
+    });
+    const testAttributesObject2 = { name: 'this2', value: 'that2' };
+    expect(mapDeviceAttributes([testAttributesObject1, testAttributesObject2])).toEqual({
+      ...defaultAttributes,
+      inventory: {
+        ...defaultAttributes.inventory,
+        this1: 'that1',
+        this2: 'that2'
+      }
+    });
+    expect(mapDeviceAttributes([testAttributesObject1, testAttributesObject2, testAttributesObject2])).toEqual({
+      ...defaultAttributes,
+      inventory: {
+        ...defaultAttributes.inventory,
+        this1: 'that1',
+        this2: 'that2'
+      }
+    });
+  });
+  it('handles scoped attributes', async () => {
+    const testAttributesObject1 = { name: 'this1', value: 'that1', scope: 'inventory' };
+    expect(mapDeviceAttributes([testAttributesObject1])).toEqual({
+      ...defaultAttributes,
+      inventory: {
+        ...defaultAttributes.inventory,
+        this1: 'that1'
+      }
+    });
+    const testAttributesObject2 = { name: 'this2', value: 'that2', scope: 'identity' };
+    expect(mapDeviceAttributes([testAttributesObject1, testAttributesObject2])).toEqual({
+      ...defaultAttributes,
+      identity: {
+        ...defaultAttributes.identity,
+        this2: 'that2'
+      },
+      inventory: {
+        ...defaultAttributes.inventory,
+        this1: 'that1'
+      }
+    });
+    expect(mapDeviceAttributes([testAttributesObject1, testAttributesObject2, testAttributesObject2])).toEqual({
+      ...defaultAttributes,
+      identity: {
+        ...defaultAttributes.identity,
+        this2: 'that2'
+      },
+      inventory: {
+        ...defaultAttributes.inventory,
+        this1: 'that1'
+      }
+    });
+  });
+});
+
+describe('preformatWithRequestID function', () => {
+  it('works as expected', async () => {
+    expect(preformatWithRequestID({ data: { request_id: 'someUuidLikeLongerText' } }, token)).toEqual(
+      'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJjZTNkMGY4Yy1hZWRlLTQwMzAtYjM5MS03ZDUwMjBlYjg3M2UiLCJzdWIiOiJhMzBhNzgwYi1iODQzLTUzNDQtODBlMy0wZmQ5NWE0ZjZmYzMiLCJleHAiOjE2MDY4MTUzNjksImlhdCI6MTYwNjIxMDU2OSwibWVuZGVyLnRlbmF... [Request ID: someUuid]'
+    );
+    expect(preformatWithRequestID({ data: {} }, token)).toEqual(
+      'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJjZTNkMGY4Yy1hZWRlLTQwMzAtYjM5MS03ZDUwMjBlYjg3M2UiLCJzdWIiOiJhMzBhNzgwYi1iODQzLTUzNDQtODBlMy0wZmQ5NWE0ZjZmYzMiLCJleHAiOjE2MDY4MTUzNjksImlhdCI6MTYwNjIxMDU2OSwibWVuZGVyLnRlbmF...'
+    );
+    expect(preformatWithRequestID(undefined, token)).toEqual(
+      'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJjZTNkMGY4Yy1hZWRlLTQwMzAtYjM5MS03ZDUwMjBlYjg3M2UiLCJzdWIiOiJhMzBhNzgwYi1iODQzLTUzNDQtODBlMy0wZmQ5NWE0ZjZmYzMiLCJleHAiOjE2MDY4MTUzNjksImlhdCI6MTYwNjIxMDU2OSwibWVuZGVyLnRlbmF...'
+    );
+    const expectedText = 'short text';
+    expect(preformatWithRequestID({ data: { request_id: 'someUuidLikeLongerText' } }, expectedText)).toEqual('short text [Request ID: someUuid]');
+    expect(preformatWithRequestID(undefined, expectedText)).toEqual(expectedText);
+  });
+});
+
+describe('generateDeploymentGroupDetails function', () => {
+  it('works as expected', async () => {
+    expect(generateDeploymentGroupDetails({ terms: defaultState.devices.groups.byId.testGroupDynamic.filters }, 'testGroupDynamic')).toEqual(
+      'testGroupDynamic (group = things)'
+    );
+    expect(
+      generateDeploymentGroupDetails(
+        {
+          terms: [
+            { scope: 'system', key: 'group', operator: '$eq', value: 'things' },
+            { scope: 'system', key: 'group', operator: '$nexists', value: 'otherThings' },
+            { scope: 'system', key: 'group', operator: '$nin', value: 'a,small,list' }
+          ]
+        },
+        'testGroupDynamic'
+      )
+    ).toEqual(`testGroupDynamic (group = things, group doesn't exist otherThings, group not in a,small,list)`);
+    expect(generateDeploymentGroupDetails({ terms: undefined }, 'testGroupDynamic')).toEqual('testGroupDynamic');
+  });
+});
+
+describe('deployment stats grouping functions', () => {
+  it('groups correctly based on deployment stats', async () => {
+    let deployment = {
+      statistics: {
+        status: {
+          aborted: 2,
+          'already-installed': 1,
+          decommissioned: 1,
+          downloading: 3,
+          failure: 1,
+          installing: 1,
+          noartifact: 1,
+          pending: 2,
+          paused: 0,
+          rebooting: 1,
+          success: 1
+        }
+      }
+    };
+    expect(groupDeploymentStats(deployment)).toEqual({ inprogress: 5, paused: 0, pending: 2, successes: 3, failures: 4 });
+    deployment = { ...deployment, max_devices: 100, device_count: 10 };
+    expect(groupDeploymentStats(deployment)).toEqual({ inprogress: 5, paused: 0, pending: 92, successes: 3, failures: 4 });
+  });
+  it('groups correctly based on deployment devices states', async () => {
+    const deployment = {
+      devices: {
+        a: { status: 'aborted' },
+        b: { status: 'already-installed' },
+        c: { status: 'decommissioned' },
+        d: { status: 'downloading' },
+        e: { status: 'failure' },
+        f: { status: 'installing' },
+        g: { status: 'noartifact' },
+        h: { status: 'pending' },
+        i: { status: 'rebooting' },
+        j: { status: 'success' }
+      }
+    };
+    expect(groupDeploymentDevicesStats(deployment)).toEqual({ inprogress: 3, paused: 0, pending: 1, successes: 3, failures: 3 });
+  });
+});
+
+describe('isDarkMode function', () => {
+  it('should return `true` if DARK_MODE was passed in', () => {
+    expect(isDarkMode(DARK_MODE)).toEqual(true);
+  });
+  it('should return `false` if LIGHT_MODE was passed in', () => {
+    expect(isDarkMode(LIGHT_MODE)).toEqual(false);
+  });
+});

package/utils.ts

@@ -0,0 +1,249 @@
+// Copyright 2024 Northern.tech AS
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// @ts-nocheck
+import { duplicateFilter, yes } from '@northern.tech/utils/helpers';
+
+import { ATTRIBUTE_SCOPES, DEVICE_FILTERING_OPTIONS, DEVICE_ISSUE_OPTIONS, DEVICE_LIST_MAXIMUM_LENGTH, emptyUiPermissions } from './commonConstants';
+import {
+  DARK_MODE,
+  DEPLOYMENT_STATES,
+  defaultStats,
+  deploymentDisplayStates,
+  deploymentStatesToSubstates,
+  deploymentStatesToSubstatesWithSkipped,
+  emptyFilter
+} from './constants';
+
+// for some reason these functions can not be stored in the deviceConstants...
+const filterProcessors = {
+  $gt: val => Number(val) || val,
+  $gte: val => Number(val) || val,
+  $lt: val => Number(val) || val,
+  $lte: val => Number(val) || val,
+  $in: val => ('' + val).split(',').map(i => i.trim()),
+  $nin: val => ('' + val).split(',').map(i => i.trim()),
+  $exists: yes,
+  $nexists: () => false
+};
+const filterAliases = {
+  $nexists: { alias: DEVICE_FILTERING_OPTIONS.$exists.key, value: false }
+};
+export const mapFiltersToTerms = filters =>
+  filters.map(filter => ({
+    scope: filter.scope,
+    attribute: filter.key,
+    type: filterAliases[filter.operator]?.alias || filter.operator,
+    value: filterProcessors.hasOwnProperty(filter.operator) ? filterProcessors[filter.operator](filter.value) : filter.value
+  }));
+export const mapTermsToFilters = terms =>
+  terms.map(term => {
+    const aliasedFilter = Object.entries(filterAliases).find(
+      aliasDefinition => aliasDefinition[1].alias === term.type && aliasDefinition[1].value === term.value
+    );
+    const operator = aliasedFilter ? aliasedFilter[0] : term.type;
+    return { scope: term.scope, key: term.attribute, operator, value: term.value };
+  });
+
+const convertIssueOptionsToFilters = (issuesSelection, filtersState = {}) =>
+  issuesSelection.map(item => {
+    if (typeof DEVICE_ISSUE_OPTIONS[item].filterRule.value === 'function') {
+      return { ...DEVICE_ISSUE_OPTIONS[item].filterRule, value: DEVICE_ISSUE_OPTIONS[item].filterRule.value(filtersState) };
+    }
+    return DEVICE_ISSUE_OPTIONS[item].filterRule;
+  });
+
+export const convertDeviceListStateToFilters = ({ filters = [], group, groups = { byId: {} }, offlineThreshold, selectedIssues = [], status }) => {
+  let applicableFilters = [...filters];
+  if (typeof group === 'string' && !(groups.byId[group]?.filters || applicableFilters).length) {
+    applicableFilters.push({ key: 'group', value: group, operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: 'system' });
+  }
+  const nonMonitorFilters = applicableFilters.filter(
+    filter =>
+      !Object.values(DEVICE_ISSUE_OPTIONS).some(
+        ({ filterRule }) => filter.scope !== 'inventory' && filterRule.scope === filter.scope && filterRule.key === filter.key
+      )
+  );
+  const deviceIssueFilters = convertIssueOptionsToFilters(selectedIssues, { offlineThreshold });
+  applicableFilters = [...nonMonitorFilters, ...deviceIssueFilters];
+  const effectiveFilters = status
+    ? [...applicableFilters, { key: 'status', value: status, operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: 'identity' }]
+    : applicableFilters;
+  return { applicableFilters: nonMonitorFilters, filterTerms: mapFiltersToTerms(effectiveFilters) };
+};
+
+const filterCompare = (filter, item) => Object.keys(emptyFilter).every(key => item[key].toString() === filter[key].toString());
+
+export const filtersFilter = (item, index, array) => {
+  const firstIndex = array.findIndex(filter => filterCompare(filter, item));
+  return firstIndex === index;
+};
+
+export const listItemMapper = (byId, ids, { defaultObject = {}, cutOffSize = DEVICE_LIST_MAXIMUM_LENGTH }) => {
+  return ids.slice(0, cutOffSize).reduce((accu, id) => {
+    if (id && byId[id]) {
+      accu.push({ ...defaultObject, ...byId[id] });
+    }
+    return accu;
+  }, []);
+};
+
+export const mergePermissions = (existingPermissions = { ...emptyUiPermissions }, addedPermissions) =>
+  Object.entries(existingPermissions).reduce(
+    (accu, [key, value]) => {
+      let values;
+      if (!accu[key]) {
+        accu[key] = value;
+        return accu;
+      }
+      if (Array.isArray(value)) {
+        values = [...value, ...accu[key]].filter(duplicateFilter);
+      } else {
+        values = mergePermissions(accu[key], { ...value });
+      }
+      accu[key] = values;
+      return accu;
+    },
+    { ...addedPermissions }
+  );
+
+export const mapUserRolesToUiPermissions = (userRoles, roles) =>
+  userRoles.reduce(
+    (accu, roleId) => {
+      if (!(roleId && roles[roleId])) {
+        return accu;
+      }
+      return mergePermissions(accu, roles[roleId].uiPermissions);
+    },
+    { ...emptyUiPermissions }
+  );
+
+export const progress = ({ loaded, total }) => {
+  let uploadProgress = (loaded / total) * 100;
+  return (uploadProgress = uploadProgress < 50 ? Math.ceil(uploadProgress) : Math.round(uploadProgress));
+};
+
+export const extractErrorMessage = (err, fallback = '') =>
+  err.response?.data?.error?.message || err.response?.data?.error || err.error || err.message || fallback;
+
+export const preformatWithRequestID = (res, failMsg) => {
+  // ellipsis line
+  if (failMsg.length > 100) failMsg = `${failMsg.substring(0, 220)}...`;
+
+  try {
+    if (res?.data && Object.keys(res.data).includes('request_id')) {
+      let shortRequestUUID = res.data['request_id'].substring(0, 8);
+      return `${failMsg} [Request ID: ${shortRequestUUID}]`;
+    }
+  } catch (e) {
+    console.log('failed to extract request id:', e);
+  }
+  return failMsg;
+};
+
+export const getComparisonCompatibleVersion = version => (isNaN(version.charAt(0)) && version !== 'next' ? 'master' : version);
+
+export const stringToBoolean = content => {
+  if (!content) {
+    return false;
+  }
+  const string = content + '';
+  switch (string.trim().toLowerCase()) {
+    case 'true':
+    case 'yes':
+    case '1':
+      return true;
+    case 'false':
+    case 'no':
+    case '0':
+    case null:
+      return false;
+    default:
+      return Boolean(string);
+  }
+};
+
+export const groupDeploymentDevicesStats = deployment => {
+  const deviceStatCollector = (deploymentStates, devices) =>
+    Object.values(devices).reduce((accu, device) => (deploymentStates.includes(device.status) ? accu + 1 : accu), 0);
+
+  const inprogress = deviceStatCollector(deploymentStatesToSubstates.inprogress, deployment.devices);
+  const pending = deviceStatCollector(deploymentStatesToSubstates.pending, deployment.devices);
+  const successes = deviceStatCollector(deploymentStatesToSubstates.successes, deployment.devices);
+  const failures = deviceStatCollector(deploymentStatesToSubstates.failures, deployment.devices);
+  const paused = deviceStatCollector(deploymentStatesToSubstates.paused, deployment.devices);
+  return { inprogress, paused, pending, successes, failures };
+};
+
+export const statCollector = (items, statistics) => items.reduce((accu, property) => accu + Number(statistics[property] || 0), 0);
+export const groupDeploymentStats = (deployment, withSkipped) => {
+  const { statistics = {} } = deployment;
+  const { status = {} } = statistics;
+  const stats = { ...defaultStats, ...status };
+  let groupStates = deploymentStatesToSubstates;
+  let result = {};
+  if (withSkipped) {
+    groupStates = deploymentStatesToSubstatesWithSkipped;
+    result.skipped = statCollector(groupStates.skipped, stats);
+  }
+  result = {
+    ...result,
+    // don't include 'pending' as inprogress, as all remaining devices will be pending - we don't discriminate based on phase membership
+    inprogress: statCollector(groupStates.inprogress, stats),
+    pending: (deployment.max_devices ? deployment.max_devices - deployment.device_count : 0) + statCollector(groupStates.pending, stats),
+    successes: statCollector(groupStates.successes, stats),
+    failures: statCollector(groupStates.failures, stats),
+    paused: statCollector(groupStates.paused, stats)
+  };
+  return result;
+};
+
+export const getDeploymentState = deployment => {
+  const { status: deploymentStatus = DEPLOYMENT_STATES.pending } = deployment;
+  const { inprogress: currentProgressCount, paused } = groupDeploymentStats(deployment);
+
+  let status = deploymentDisplayStates[deploymentStatus];
+  if (deploymentStatus === DEPLOYMENT_STATES.pending && currentProgressCount === 0) {
+    status = 'queued';
+  } else if (paused > 0) {
+    status = deploymentDisplayStates.paused;
+  }
+  return status;
+};
+
+export const generateDeploymentGroupDetails = (filter, groupName) =>
+  filter && filter.terms?.length
+    ? `${groupName} (${filter.terms
+        .map(filter => `${filter.attribute || filter.key} ${DEVICE_FILTERING_OPTIONS[filter.type || filter.operator].shortform} ${filter.value}`)
+        .join(', ')})`
+    : groupName;
+
+export const mapDeviceAttributes = (attributes = []) =>
+  attributes.reduce(
+    (accu, attribute) => {
+      if (!(attribute.value && attribute.name) && attribute.scope === ATTRIBUTE_SCOPES.inventory) {
+        return accu;
+      }
+      accu[attribute.scope || ATTRIBUTE_SCOPES.inventory] = {
+        ...accu[attribute.scope || ATTRIBUTE_SCOPES.inventory],
+        [attribute.name]: attribute.value
+      };
+      if (attribute.name === 'device_type' && attribute.scope === ATTRIBUTE_SCOPES.inventory) {
+        accu.inventory.device_type = [].concat(attribute.value);
+      }
+      return accu;
+    },
+    { inventory: { device_type: [], artifact_name: '' }, identity: {}, monitor: {}, system: {}, tags: {} }
+  );
+
+export const isDarkMode = mode => mode === DARK_MODE;