1057188406

Committed 01 Nov 2023 04:24AM UTC coverage: 82.824% (-17.1%) from 99.964%

Build # 1057188406

Build Type

Pull #4134

gitlab-ci

Committed by

web-flow

Commit Message

chore: Bump uuid from 9.0.0 to 9.0.1

Bumps [uuid](https://github.com/uuidjs/uuid) from 9.0.0 to 9.0.1.
- [Changelog](https://github.com/uuidjs/uuid/blob/main/CHANGELOG.md)
- [Commits](https://github.com/uuidjs/uuid/compare/v9.0.0...v9.0.1)

---
updated-dependencies:
- dependency-name: uuid
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #4134: chore: Bump uuid from 9.0.0 to 9.0.1

Run Details

4349 of 6284 branches covered (0.0%)

8313 of 10037 relevant lines covered (82.82%)

200.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.81

/src/js/helpers.js

// Copyright 2017 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.
import React from 'react';

import jwtDecode from 'jwt-decode';
import pluralize from 'pluralize';

import { getToken } from './auth';
import { DARK_MODE } from './constants/appConstants';
import {
  DEPLOYMENT_STATES,
  defaultStats,
  deploymentDisplayStates,
  deploymentStatesToSubstates,
  deploymentStatesToSubstatesWithSkipped
} from './constants/deploymentConstants';
import { ATTRIBUTE_SCOPES, DEVICE_FILTERING_OPTIONS } from './constants/deviceConstants';

const isEncoded = uri => {
  uri = uri || '';
  return uri !== decodeURIComponent(uri);
};

export const fullyDecodeURI = uri => {
  while (isEncoded(uri)) {
    uri = decodeURIComponent(uri);
  }
  return uri;
};

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 decodeSessionToken = token => {
  try {
    var decoded = jwtDecode(token);
    return decoded.sub;
  } catch (err) {
    //console.log(err);
    return;
  }
};

export const isEmpty = obj => {
  for (const _ in obj) {
    return false;
  }
  return true;
};

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 versionCompare = (v1, v2) => {
  const partsV1 = `${v1}`.split('.');
  const partsV2 = `${v2}`.split('.');
  for (let index = 0; index < partsV1.length; index++) {
    const numberV1 = partsV1[index];
    const numberV2 = partsV2[index];
    if (numberV1 > numberV2) {
      return 1;
    }
    if (numberV2 > numberV1) {
      return -1;
    }
  }
  return 0;
};

/*
 *
 * Deep compare
 *
 */
// eslint-disable-next-line sonarjs/cognitive-complexity
export function deepCompare() {
  var i, l, leftChain, rightChain;

  function compare2Objects(x, y) {
    var p;

    // remember that NaN === NaN returns false
    // and isNaN(undefined) returns true
    if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
      return true;
    }

    // Compare primitives and functions.
    // Check if both arguments link to the same object.
    // Especially useful on the step where we compare prototypes
    if (x === y) {
      return true;
    }

    // Works in case when functions are created in constructor.
    // Comparing dates is a common scenario. Another built-ins?
    // We can even handle functions passed across iframes
    if (
      (typeof x === 'function' && typeof y === 'function') ||
      (x instanceof Date && y instanceof Date) ||
      (x instanceof RegExp && y instanceof RegExp) ||
      (x instanceof String && y instanceof String) ||
      (x instanceof Number && y instanceof Number)
    ) {
      return x.toString() === y.toString();
    }

    // At last checking prototypes as good as we can
    if (!(x instanceof Object && y instanceof Object)) {
      return false;
    }

    if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
      return false;
    }

    if (x.constructor !== y.constructor) {
      return false;
    }

    if (x.prototype !== y.prototype) {
      return false;
    }

    // Check for infinitive linking loops
    if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
      return false;
    }

    // Quick checking of one object being a subset of another.
    // todo: cache the structure of arguments[0] for performance
    for (p in y) {
      if (y.hasOwnProperty(p) !== x.hasOwnProperty(p) || typeof y[p] !== typeof x[p]) {
        return false;
      }
    }

    for (p in x) {
      if (y.hasOwnProperty(p) !== x.hasOwnProperty(p) || typeof y[p] !== typeof x[p]) {
        return false;
      }

      switch (typeof x[p]) {
        case 'object':
        case 'function':
          leftChain.push(x);
          rightChain.push(y);

          if (!compare2Objects(x[p], y[p])) {
            return false;
          }

          leftChain.pop();
          rightChain.pop();
          break;

        default:
          if (x[p] !== y[p]) {
            return false;
          }
          break;
      }
    }

    return true;
  }

  if (arguments.length < 1) {
    return true; //Die silently? Don't know how to handle such case, please help...
    // throw "Need two or more arguments to compare";
  }

  for (i = 1, l = arguments.length; i < l; i++) {
    leftChain = []; //Todo: this can be cached
    rightChain = [];

    if (!compare2Objects(arguments[0], arguments[i])) {
      return false;
    }
  }

  return true;
}

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 toggle = current => !current;

export const formatTime = date => {
  if (date && Object.prototype.toString.call(date) === '[object Date]' && !isNaN(date)) {
    return date.toISOString().slice(0, -1);
  } else if (date) {
    return date.replace(' ', 'T').replace(/ /g, '').replace('UTC', '');
  }
};

export const customSort = (direction, field) => (a, b) => {
  if (typeof a[field] === 'string') {
    const result = a[field].localeCompare(b[field], { sensitivity: 'case' });
    return direction ? result * -1 : result;
  }
  if (a[field] > b[field]) return direction ? -1 : 1;
  if (a[field] < b[field]) return direction ? 1 : -1;
  return 0;
};

export const duplicateFilter = (item, index, array) => array.indexOf(item) == index;

export const attributeDuplicateFilter = (filterableArray, attributeName = 'key') =>
  filterableArray.filter(
    (item, index, array) => array.findIndex(filter => filter[attributeName] === item[attributeName] && filter.scope === item.scope) == index
  );

export const unionizeStrings = (someStrings, someOtherStrings) => {
  const startingPoint = new Set(someStrings.filter(item => item.length));
  const uniqueStrings = someOtherStrings.length
    ? someOtherStrings.reduce((accu, item) => {
        if (item.trim().length) {
          accu.add(item.trim());
        }
        return accu;
      }, startingPoint)
    : startingPoint;
  return [...uniqueStrings];
};

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 getFormattedSize = bytes => {
  const suffixes = ['Bytes', 'KB', 'MB', 'GB'];
  const i = Math.floor(Math.log(bytes) / Math.log(1024));
  if (!bytes) {
    return '0 Bytes';
  }
  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${suffixes[i]}`;
};

export const FileSize = React.forwardRef(({ fileSize, style }, ref) => (
  <div ref={ref} style={style}>
    {getFormattedSize(fileSize)}
  </div>
));
FileSize.displayName = 'FileSize';

const collectAddressesFrom = devices =>
  devices.reduce((collector, { attributes = {} }) => {
    const ips = Object.entries(attributes).reduce((accu, [name, value]) => {
      if (name.startsWith('ipv4')) {
        if (Array.isArray(value)) {
          const texts = value.map(text => text.slice(0, text.indexOf('/')));
          accu.push(...texts);
        } else {
          const text = value.slice(0, value.indexOf('/'));
          accu.push(text);
        }
      }
      return accu;
    }, []);
    collector.push(...ips);
    return collector;
  }, []);

export const getDemoDeviceAddress = (devices, onboardingApproach) => {
  const defaultVitualizedIp = '10.0.2.15';
  const addresses = collectAddressesFrom(devices);
  const address = addresses.reduce((accu, item) => {
    if (accu && item === defaultVitualizedIp) {
      return accu;
    }
    return item;
  }, null);
  if (!address || (onboardingApproach === 'virtual' && (navigator.appVersion.indexOf('Win') != -1 || navigator.appVersion.indexOf('Mac') != -1))) {
    return 'localhost';
  }
  return address;
};

export const detectOsIdentifier = () => {
  if (navigator.appVersion.indexOf('Win') != -1) return 'Windows';
  if (navigator.appVersion.indexOf('Mac') != -1) return 'MacOs';
  if (navigator.appVersion.indexOf('X11') != -1) return 'Unix';
  return 'Linux';
};

export const getRemainderPercent = phases => {
  // remove final phase size if set
  phases[phases.length - 1].batch_size = null;
  // use this to get remaining percent of final phase so we don't set a hard number
  return phases.reduce((accu, phase) => (phase.batch_size ? accu - phase.batch_size : accu), 100);
};

export const validatePhases = (phases, deploymentDeviceCount, hasFilter) => {
  if (!phases?.length) {
    return true;
  }
  const remainder = getRemainderPercent(phases);
  return phases.reduce((accu, phase) => {
    if (!accu) {
      return accu;
    }
    const deviceCount = Math.floor((deploymentDeviceCount / 100) * (phase.batch_size || remainder));
    return deviceCount >= 1 || hasFilter;
  }, true);
};

export const getPhaseDeviceCount = (numberDevices = 1, batchSize, remainder, isLastPhase) =>
  isLastPhase ? Math.ceil((numberDevices / 100) * (batchSize || remainder)) : Math.floor((numberDevices / 100) * (batchSize || remainder));

export const startTimeSort = (a, b) => (b.created > a.created) - (b.created < a.created);

export const standardizePhases = phases =>
  phases.map((phase, index) => {
    let standardizedPhase = { batch_size: phase.batch_size, start_ts: index };
    if (phase.delay) {
      standardizedPhase.delay = phase.delay;
      standardizedPhase.delayUnit = phase.delayUnit || 'hours';
    }
    if (index === 0) {
      // delete the start timestamp from a deployment pattern, to default to starting without delay
      delete standardizedPhase.start_ts;
    }
    return standardizedPhase;
  });

const getInstallScriptArgs = ({ isHosted, isPreRelease }) => {
  let installScriptArgs = '--demo';
  installScriptArgs = isPreRelease ? `${installScriptArgs} -c experimental` : installScriptArgs;
  installScriptArgs = isHosted ? `${installScriptArgs} --commercial --jwt-token $JWT_TOKEN` : installScriptArgs;
  return installScriptArgs;
};

const getSetupArgs = ({ deviceType = 'generic-armv6', ipAddress, isDemoMode, tenantToken, isOnboarding }) => {
  let menderSetupArgs = `--quiet --device-type "${deviceType}"`;
  menderSetupArgs = tenantToken ? `${menderSetupArgs} --tenant-token $TENANT_TOKEN` : menderSetupArgs;
  // in production we use polling intervals from the client examples: https://github.com/mendersoftware/mender/blob/master/examples/mender.conf.production
  menderSetupArgs = isDemoMode || isOnboarding ? `${menderSetupArgs} --demo` : `${menderSetupArgs} --retry-poll 300 --update-poll 1800 --inventory-poll 28800`;
  if (isDemoMode) {
    // Demo installation, either OS os Enterprise. Install demo cert and add IP to /etc/hosts
    menderSetupArgs = `${menderSetupArgs}${ipAddress ? ` --server-ip ${ipAddress}` : ''}`;
  } else {
    // Production installation, either OS, HM, or Enterprise
    menderSetupArgs = `${menderSetupArgs} --server-url https://${window.location.hostname} --server-cert=""`;
  }
  return menderSetupArgs;
};

export const getDebConfigurationCode = props => {
  const { tenantToken, isPreRelease } = props;
  const envVars = tenantToken ? `JWT_TOKEN="${getToken()}"\nTENANT_TOKEN="${tenantToken}"\n` : '';
  const installScriptArgs = getInstallScriptArgs(props);
  const scriptUrl = isPreRelease ? 'https://get.mender.io/staging' : 'https://get.mender.io';
  const menderSetupArgs = getSetupArgs(props);
  return `${envVars}wget -O- ${scriptUrl} | sudo bash -s -- ${installScriptArgs} -- ${menderSetupArgs}`;
};

export const getSnackbarMessage = (skipped, done) => {
  pluralize.addIrregularRule('its', 'their');
  const skipText = skipped
    ? `${skipped} ${pluralize('devices', skipped)} ${pluralize('have', skipped)} more than one pending authset. Expand ${pluralize(
        'this',
        skipped
      )} ${pluralize('device', skipped)} to individually adjust ${pluralize('their', skipped)} authorization status. `
    : '';
  const doneText = done ? `${done} ${pluralize('device', done)} ${pluralize('was', done)} updated successfully. ` : '';
  return `${doneText}${skipText}`;
};

export const extractSoftware = (attributes = {}) => {
  const softwareKeys = Object.keys(attributes).reduce((accu, item) => {
    if (item.endsWith('.version')) {
      accu.push(item.substring(0, item.lastIndexOf('.')));
    }
    return accu;
  }, []);
  return Object.entries(attributes).reduce(
    (accu, item) => {
      if (softwareKeys.some(key => item[0].startsWith(key))) {
        accu.software.push(item);
      } else {
        accu.nonSoftware.push(item);
      }
      return accu;
    },
    { software: [], nonSoftware: [] }
  );
};

export const extractSoftwareItem = (artifactProvides = {}) => {
  const { software } = extractSoftware(artifactProvides);
  return (
    software
      .reduce((accu, item) => {
        const infoItems = item[0].split('.');
        if (infoItems[infoItems.length - 1] !== 'version') {
          return accu;
        }
        accu.push({ key: infoItems[0], name: infoItems.slice(1, infoItems.length - 1).join('.'), version: item[1], nestingLevel: infoItems.length });
        return accu;
      }, [])
      // we assume the smaller the nesting level in the software name, the closer the software is to the rootfs/ the higher the chances we show the rootfs
      // sort based on this assumption & then only return the first item (can't use index access, since there might not be any software item at all)
      .sort((a, b) => a.nestingLevel - b.nestingLevel)
      .reduce((accu, item) => accu ?? item, undefined)
  );
};

export const createDownload = (target, filename) => {
  let link = document.createElement('a');
  link.setAttribute('href', target);
  link.setAttribute('download', filename);
  link.style.display = 'none';
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
};

export const createFileDownload = (content, filename) => createDownload('data:text/plain;charset=utf-8,' + encodeURIComponent(content), filename);

export const getISOStringBoundaries = currentDate => {
  const date = [currentDate.getUTCFullYear(), `0${currentDate.getUTCMonth() + 1}`.slice(-2), `0${currentDate.getUTCDate()}`.slice(-2)].join('-');
  return { start: `${date}T00:00:00.000`, end: `${date}T23:59:59.999` };
};

export const isDarkMode = mode => mode === DARK_MODE;

1	// Copyright 2017 Northern.tech AS
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14	import React from 'react';
15
16	import jwtDecode from 'jwt-decode';
17	import pluralize from 'pluralize';
18
19	import { getToken } from './auth';
20	import { DARK_MODE } from './constants/appConstants';
21	import {
22	DEPLOYMENT_STATES,
23	defaultStats,
24	deploymentDisplayStates,
25	deploymentStatesToSubstates,
26	deploymentStatesToSubstatesWithSkipped
27	} from './constants/deploymentConstants';
28	import { ATTRIBUTE_SCOPES, DEVICE_FILTERING_OPTIONS } from './constants/deviceConstants';
29
30	const isEncoded = uri => {	184✔
31	uri = uri \|\| '';	8✔
32	return uri !== decodeURIComponent(uri);	8✔
33	};
34
35	export const fullyDecodeURI = uri => {	184✔
36	while (isEncoded(uri)) {	6✔
37	uri = decodeURIComponent(uri);	2✔
38	}
39	return uri;	6✔
40	};
41
42	export const groupDeploymentDevicesStats = deployment => {	184✔
43	const deviceStatCollector = (deploymentStates, devices) =>	1✔
44	Object.values(devices).reduce((accu, device) => (deploymentStates.includes(device.status) ? accu + 1 : accu), 0);	50✔
45
46	const inprogress = deviceStatCollector(deploymentStatesToSubstates.inprogress, deployment.devices);	1✔
47	const pending = deviceStatCollector(deploymentStatesToSubstates.pending, deployment.devices);	1✔
48	const successes = deviceStatCollector(deploymentStatesToSubstates.successes, deployment.devices);	1✔
49	const failures = deviceStatCollector(deploymentStatesToSubstates.failures, deployment.devices);	1✔
50	const paused = deviceStatCollector(deploymentStatesToSubstates.paused, deployment.devices);	1✔
51	return { inprogress, paused, pending, successes, failures };	1✔
52	};
53
54	export const statCollector = (items, statistics) => items.reduce((accu, property) => accu + Number(statistics[property] \|\| 0), 0);	51,838✔
55	export const groupDeploymentStats = (deployment, withSkipped) => {	184✔
56	const { statistics = {} } = deployment;	3,982✔
57	const { status = {} } = statistics;	3,982✔
58	const stats = { ...defaultStats, ...status };	3,982✔
59	let groupStates = deploymentStatesToSubstates;	3,982✔
60	let result = {};	3,982✔
61	if (withSkipped) {	3,982✔
62	groupStates = deploymentStatesToSubstatesWithSkipped;	2,002✔
63	result.skipped = statCollector(groupStates.skipped, stats);	2,002✔
64	}
65	result = {	3,982✔
66	...result,
67	// don't include 'pending' as inprogress, as all remaining devices will be pending - we don't discriminate based on phase membership
68	inprogress: statCollector(groupStates.inprogress, stats),
69	pending: (deployment.max_devices ? deployment.max_devices - deployment.device_count : 0) + statCollector(groupStates.pending, stats),	3,982✔
70	successes: statCollector(groupStates.successes, stats),
71	failures: statCollector(groupStates.failures, stats),
72	paused: statCollector(groupStates.paused, stats)
73	};
74	return result;	3,982✔
75	};
76
77	export const getDeploymentState = deployment => {	184✔
78	const { status: deploymentStatus = DEPLOYMENT_STATES.pending } = deployment;	1,966✔
79	const { inprogress: currentProgressCount, paused } = groupDeploymentStats(deployment);	1,966✔
80
81	let status = deploymentDisplayStates[deploymentStatus];	1,966✔
82	if (deploymentStatus === DEPLOYMENT_STATES.pending && currentProgressCount === 0) {	1,966✔
83	status = 'queued';	979✔
84	} else if (paused > 0) {	987!
85	status = deploymentDisplayStates.paused;	×
86	}
87	return status;	1,966✔
88	};
89
90	export const decodeSessionToken = token => {	184✔
91	try {	5✔
92	var decoded = jwtDecode(token);	5✔
93	return decoded.sub;	3✔
94	} catch (err) {
95	//console.log(err);
96	return;	2✔
97	}
98	};
99
100	export const isEmpty = obj => {	184✔
101	for (const _ in obj) {	392✔
102	return false;	181✔
103	}
104	return true;	211✔
105	};
106
107	export const extractErrorMessage = (err, fallback = '') =>	184✔
108	err.response?.data?.error?.message \|\| err.response?.data?.error \|\| err.error \|\| err.message \|\| fallback;	12!
109
110	export const preformatWithRequestID = (res, failMsg) => {	184✔
111	// ellipsis line
112	if (failMsg.length > 100) failMsg = `${failMsg.substring(0, 220)}...`;	11✔
113
114	try {	11✔
115	if (res?.data && Object.keys(res.data).includes('request_id')) {	11✔
116	let shortRequestUUID = res.data['request_id'].substring(0, 8);	2✔
117	return `${failMsg} [Request ID: ${shortRequestUUID}]`;	2✔
118	}
119	} catch (e) {
120	console.log('failed to extract request id:', e);	×
121	}
122	return failMsg;	9✔
123	};
124
125	export const versionCompare = (v1, v2) => {	184✔
126	const partsV1 = `${v1}`.split('.');	19✔
127	const partsV2 = `${v2}`.split('.');	19✔
128	for (let index = 0; index < partsV1.length; index++) {	19✔
129	const numberV1 = partsV1[index];	24✔
130	const numberV2 = partsV2[index];	24✔
131	if (numberV1 > numberV2) {	24✔
132	return 1;	13✔
133	}
134	if (numberV2 > numberV1) {	11✔
135	return -1;	5✔
136	}
137	}
138	return 0;	1✔
139	};
140
141	/*
142	*
143	* Deep compare
144	*
145	*/
146	// eslint-disable-next-line sonarjs/cognitive-complexity
147	export function deepCompare() {
148	var i, l, leftChain, rightChain;
149
150	function compare2Objects(x, y) {
151	var p;
152
153	// remember that NaN === NaN returns false
154	// and isNaN(undefined) returns true
155	if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {	468!
156	return true;	×
157	}
158
159	// Compare primitives and functions.
160	// Check if both arguments link to the same object.
161	// Especially useful on the step where we compare prototypes
162	if (x === y) {	468✔
163	return true;	225✔
164	}
165
166	// Works in case when functions are created in constructor.
167	// Comparing dates is a common scenario. Another built-ins?
168	// We can even handle functions passed across iframes
169	if (	243✔
170	(typeof x === 'function' && typeof y === 'function') \|\|	1,213!
171	(x instanceof Date && y instanceof Date) \|\|
172	(x instanceof RegExp && y instanceof RegExp) \|\|
173	(x instanceof String && y instanceof String) \|\|
174	(x instanceof Number && y instanceof Number)
175	) {
176	return x.toString() === y.toString();	1✔
177	}
178
179	// At last checking prototypes as good as we can
180	if (!(x instanceof Object && y instanceof Object)) {	242✔
181	return false;	17✔
182	}
183
184	if (x.isPrototypeOf(y) \|\| y.isPrototypeOf(x)) {	225!
185	return false;	×
186	}
187
188	if (x.constructor !== y.constructor) {	225!
189	return false;	×
190	}
191
192	if (x.prototype !== y.prototype) {	225!
193	return false;	×
194	}
195
196	// Check for infinitive linking loops
197	if (leftChain.indexOf(x) > -1 \|\| rightChain.indexOf(y) > -1) {	225!
198	return false;	×
199	}
200
201	// Quick checking of one object being a subset of another.
202	// todo: cache the structure of arguments[0] for performance
203	for (p in y) {	225✔
204	if (y.hasOwnProperty(p) !== x.hasOwnProperty(p) \|\| typeof y[p] !== typeof x[p]) {	1,042✔
205	return false;	55✔
206	}
207	}
208
209	for (p in x) {	170✔
210	if (y.hasOwnProperty(p) !== x.hasOwnProperty(p) \|\| typeof y[p] !== typeof x[p]) {	680✔
211	return false;	9✔
212	}
213
214	switch (typeof x[p]) {	671✔
215	case 'object':
216	case 'function':
217	leftChain.push(x);	279✔
218	rightChain.push(y);	279✔
219
220	if (!compare2Objects(x[p], y[p])) {	279✔
221	return false;	12✔
222	}
223
224	leftChain.pop();	267✔
225	rightChain.pop();	267✔
226	break;	267✔
227
228	default:
229	if (x[p] !== y[p]) {	392✔
230	return false;	7✔
231	}
232	break;	385✔
233	}
234	}
235
236	return true;	142✔
237	}
238
239	if (arguments.length < 1) {	187!
240	return true; //Die silently? Don't know how to handle such case, please help...	×
241	// throw "Need two or more arguments to compare";
242	}
243
244	for (i = 1, l = arguments.length; i < l; i++) {	187✔
245	leftChain = []; //Todo: this can be cached	189✔
246	rightChain = [];	189✔
247
248	if (!compare2Objects(arguments[0], arguments[i])) {	189✔
249	return false;	88✔
250	}
251	}
252
253	return true;	99✔
254	}
255
256	export const stringToBoolean = content => {	184✔
257	if (!content) {	235✔
258	return false;	212✔
259	}
260	const string = content + '';	23✔
261	switch (string.trim().toLowerCase()) {	23✔
262	case 'true':
263	case 'yes':
264	case '1':
265	return true;	19✔
266	case 'false':
267	case 'no':
268	case '0':
269	case null:
270	return false;	3✔
271	default:
272	return Boolean(string);	1✔
273	}
274	};
275
276	export const toggle = current => !current;	184✔
277
278	export const formatTime = date => {	184✔
279	if (date && Object.prototype.toString.call(date) === '[object Date]' && !isNaN(date)) {	75✔
280	return date.toISOString().slice(0, -1);	1✔
281	} else if (date) {	74✔
282	return date.replace(' ', 'T').replace(/ /g, '').replace('UTC', '');	64✔
283	}
284	};
285
286	export const customSort = (direction, field) => (a, b) => {	713✔
287	if (typeof a[field] === 'string') {	192,527✔
288	const result = a[field].localeCompare(b[field], { sensitivity: 'case' });	192,416✔
289	return direction ? result * -1 : result;	192,416✔
290	}
291	if (a[field] > b[field]) return direction ? -1 : 1;	111!
292	if (a[field] < b[field]) return direction ? 1 : -1;	91!
293	return 0;	17✔
294	};
295
296	export const duplicateFilter = (item, index, array) => array.indexOf(item) == index;	3,964✔
297
298	export const attributeDuplicateFilter = (filterableArray, attributeName = 'key') =>	184!
299	filterableArray.filter(	5✔
300	(item, index, array) => array.findIndex(filter => filter[attributeName] === item[attributeName] && filter.scope === item.scope) == index	266✔
301	);
302
303	export const unionizeStrings = (someStrings, someOtherStrings) => {	184✔
304	const startingPoint = new Set(someStrings.filter(item => item.length));	24✔
305	const uniqueStrings = someOtherStrings.length	24✔
306	? someOtherStrings.reduce((accu, item) => {
307	if (item.trim().length) {	33✔
308	accu.add(item.trim());	14✔
309	}
310	return accu;	33✔
311	}, startingPoint)
312	: startingPoint;
313	return [...uniqueStrings];	24✔
314	};
315
316	export const generateDeploymentGroupDetails = (filter, groupName) =>	184✔
317	filter && filter.terms?.length	3✔
318	? `${groupName} (${filter.terms
319	.map(filter => `${filter.attribute \|\| filter.key} ${DEVICE_FILTERING_OPTIONS[filter.type \|\| filter.operator].shortform} ${filter.value}`)	4✔
320	.join(', ')})`
321	: groupName;
322
323	export const mapDeviceAttributes = (attributes = []) =>	184✔
324	attributes.reduce(	150✔
325	(accu, attribute) => {
326	if (!(attribute.value && attribute.name) && attribute.scope === ATTRIBUTE_SCOPES.inventory) {	1,678!
327	return accu;	×
328	}
329	accu[attribute.scope \|\| ATTRIBUTE_SCOPES.inventory] = {	1,678✔
330	...accu[attribute.scope \|\| ATTRIBUTE_SCOPES.inventory],	1,684✔
331	[attribute.name]: attribute.value
332	};
333	if (attribute.name === 'device_type' && attribute.scope === ATTRIBUTE_SCOPES.inventory) {	1,678✔
334	accu.inventory.device_type = [].concat(attribute.value);	81✔
335	}
336	return accu;	1,678✔
337	},
338	{ inventory: { device_type: [], artifact_name: '' }, identity: {}, monitor: {}, system: {}, tags: {} }
339	);
340
341	export const getFormattedSize = bytes => {	184✔
342	const suffixes = ['Bytes', 'KB', 'MB', 'GB'];	143✔
343	const i = Math.floor(Math.log(bytes) / Math.log(1024));	143✔
344	if (!bytes) {	143✔
345	return '0 Bytes';	31✔
346	}
347	return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${suffixes[i]}`;	112✔
348	};
349
350	export const FileSize = React.forwardRef(({ fileSize, style }, ref) => (	184✔
351	<div ref={ref} style={style}>	134✔
352	{getFormattedSize(fileSize)}
353	</div>
354	));
355	FileSize.displayName = 'FileSize';	184✔
356
357	const collectAddressesFrom = devices =>	184✔
358	devices.reduce((collector, { attributes = {} }) => {	15!
359	const ips = Object.entries(attributes).reduce((accu, [name, value]) => {	39✔
360	if (name.startsWith('ipv4')) {	132✔
361	if (Array.isArray(value)) {	27!
362	const texts = value.map(text => text.slice(0, text.indexOf('/')));	×
363	accu.push(...texts);	×
364	} else {
365	const text = value.slice(0, value.indexOf('/'));	27✔
366	accu.push(text);	27✔
367	}
368	}
369	return accu;	132✔
370	}, []);
371	collector.push(...ips);	39✔
372	return collector;	39✔
373	}, []);
374
375	export const getDemoDeviceAddress = (devices, onboardingApproach) => {	184✔
376	const defaultVitualizedIp = '10.0.2.15';	15✔
377	const addresses = collectAddressesFrom(devices);	15✔
378	const address = addresses.reduce((accu, item) => {	15✔
379	if (accu && item === defaultVitualizedIp) {	27!
380	return accu;	×
381	}
382	return item;	27✔
383	}, null);
384	if (!address \|\| (onboardingApproach === 'virtual' && (navigator.appVersion.indexOf('Win') != -1 \|\| navigator.appVersion.indexOf('Mac') != -1))) {	15✔
385	return 'localhost';	1✔
386	}
387	return address;	14✔
388	};
389
390	export const detectOsIdentifier = () => {	184✔
391	if (navigator.appVersion.indexOf('Win') != -1) return 'Windows';	3!
392	if (navigator.appVersion.indexOf('Mac') != -1) return 'MacOs';	3✔
393	if (navigator.appVersion.indexOf('X11') != -1) return 'Unix';	2!
394	return 'Linux';	2✔
395	};
396
397	export const getRemainderPercent = phases => {	184✔
398	// remove final phase size if set
399	phases[phases.length - 1].batch_size = null;	75✔
400	// use this to get remaining percent of final phase so we don't set a hard number
401	return phases.reduce((accu, phase) => (phase.batch_size ? accu - phase.batch_size : accu), 100);	203✔
402	};
403
404	export const validatePhases = (phases, deploymentDeviceCount, hasFilter) => {	184✔
405	if (!phases?.length) {	37✔
406	return true;	12✔
407	}
408	const remainder = getRemainderPercent(phases);	25✔
409	return phases.reduce((accu, phase) => {	25✔
410	if (!accu) {	66✔
411	return accu;	5✔
412	}
413	const deviceCount = Math.floor((deploymentDeviceCount / 100) * (phase.batch_size \|\| remainder));	61✔
414	return deviceCount >= 1 \|\| hasFilter;	61✔
415	}, true);
416	};
417
418	export const getPhaseDeviceCount = (numberDevices = 1, batchSize, remainder, isLastPhase) =>	184✔
419	isLastPhase ? Math.ceil((numberDevices / 100) * (batchSize \|\| remainder)) : Math.floor((numberDevices / 100) * (batchSize \|\| remainder));	129✔
420
421	export const startTimeSort = (a, b) => (b.created > a.created) - (b.created < a.created);	282✔
422
423	export const standardizePhases = phases =>	184✔
424	phases.map((phase, index) => {	3✔
425	let standardizedPhase = { batch_size: phase.batch_size, start_ts: index };	8✔
426	if (phase.delay) {	8✔
427	standardizedPhase.delay = phase.delay;	5✔
428	standardizedPhase.delayUnit = phase.delayUnit \|\| 'hours';	5✔
429	}
430	if (index === 0) {	8✔
431	// delete the start timestamp from a deployment pattern, to default to starting without delay
432	delete standardizedPhase.start_ts;	3✔
433	}
434	return standardizedPhase;	8✔
435	});
436
437	const getInstallScriptArgs = ({ isHosted, isPreRelease }) => {	184✔
438	let installScriptArgs = '--demo';	11✔
439	installScriptArgs = isPreRelease ? `${installScriptArgs} -c experimental` : installScriptArgs;	11✔
440	installScriptArgs = isHosted ? `${installScriptArgs} --commercial --jwt-token $JWT_TOKEN` : installScriptArgs;	11✔
441	return installScriptArgs;	11✔
442	};
443
444	const getSetupArgs = ({ deviceType = 'generic-armv6', ipAddress, isDemoMode, tenantToken, isOnboarding }) => {	184✔
445	let menderSetupArgs = `--quiet --device-type "${deviceType}"`;	11✔
446	menderSetupArgs = tenantToken ? `${menderSetupArgs} --tenant-token $TENANT_TOKEN` : menderSetupArgs;	11✔
447	// in production we use polling intervals from the client examples: https://github.com/mendersoftware/mender/blob/master/examples/mender.conf.production
448	menderSetupArgs = isDemoMode \|\| isOnboarding ? `${menderSetupArgs} --demo` : `${menderSetupArgs} --retry-poll 300 --update-poll 1800 --inventory-poll 28800`;	11✔
449	if (isDemoMode) {	11✔
450	// Demo installation, either OS os Enterprise. Install demo cert and add IP to /etc/hosts
451	menderSetupArgs = `${menderSetupArgs}${ipAddress ? ` --server-ip ${ipAddress}` : ''}`;	6!
452	} else {
453	// Production installation, either OS, HM, or Enterprise
454	menderSetupArgs = `${menderSetupArgs} --server-url https://${window.location.hostname} --server-cert=""`;	5✔
455	}
456	return menderSetupArgs;	11✔
457	};
458
459	export const getDebConfigurationCode = props => {	184✔
460	const { tenantToken, isPreRelease } = props;	11✔
461	const envVars = tenantToken ? `JWT_TOKEN="${getToken()}"\nTENANT_TOKEN="${tenantToken}"\n` : '';	11✔
462	const installScriptArgs = getInstallScriptArgs(props);	11✔
463	const scriptUrl = isPreRelease ? 'https://get.mender.io/staging' : 'https://get.mender.io';	11✔
464	const menderSetupArgs = getSetupArgs(props);	11✔
465	return `${envVars}wget -O- ${scriptUrl} \| sudo bash -s -- ${installScriptArgs} -- ${menderSetupArgs}`;	11✔
466	};
467
468	export const getSnackbarMessage = (skipped, done) => {	184✔
469	pluralize.addIrregularRule('its', 'their');	1✔
470	const skipText = skipped	1!
471	? `${skipped} ${pluralize('devices', skipped)} ${pluralize('have', skipped)} more than one pending authset. Expand ${pluralize(
472	'this',
473	skipped
474	)} ${pluralize('device', skipped)} to individually adjust ${pluralize('their', skipped)} authorization status. `
475	: '';
476	const doneText = done ? `${done} ${pluralize('device', done)} ${pluralize('was', done)} updated successfully. ` : '';	1!
477	return `${doneText}${skipText}`;	1✔
478	};
479
480	export const extractSoftware = (attributes = {}) => {	184✔
481	const softwareKeys = Object.keys(attributes).reduce((accu, item) => {	62✔
482	if (item.endsWith('.version')) {	162✔
483	accu.push(item.substring(0, item.lastIndexOf('.')));	73✔
484	}
485	return accu;	162✔
486	}, []);
487	return Object.entries(attributes).reduce(	62✔
488	(accu, item) => {
489	if (softwareKeys.some(key => item[0].startsWith(key))) {	272✔
490	accu.software.push(item);	88✔
491	} else {
492	accu.nonSoftware.push(item);	74✔
493	}
494	return accu;	162✔
495	},
496	{ software: [], nonSoftware: [] }
497	);
498	};
499
500	export const extractSoftwareItem = (artifactProvides = {}) => {	184✔
501	const { software } = extractSoftware(artifactProvides);	31✔
502	return (	31✔
503	software
504	.reduce((accu, item) => {
505	const infoItems = item[0].split('.');	29✔
506	if (infoItems[infoItems.length - 1] !== 'version') {	29!
507	return accu;	×
508	}
509	accu.push({ key: infoItems[0], name: infoItems.slice(1, infoItems.length - 1).join('.'), version: item[1], nestingLevel: infoItems.length });	29✔
510	return accu;	29✔
511	}, [])
512	// we assume the smaller the nesting level in the software name, the closer the software is to the rootfs/ the higher the chances we show the rootfs
513	// sort based on this assumption & then only return the first item (can't use index access, since there might not be any software item at all)
514	.sort((a, b) => a.nestingLevel - b.nestingLevel)	×
515	.reduce((accu, item) => accu ?? item, undefined)	29✔
516	);
517	};
518
519	export const createDownload = (target, filename) => {	184✔
520	let link = document.createElement('a');	1✔
521	link.setAttribute('href', target);	1✔
522	link.setAttribute('download', filename);	1✔
523	link.style.display = 'none';	1✔
524	document.body.appendChild(link);	1✔
525	link.click();	1✔
526	document.body.removeChild(link);	1✔
527	};
528
529	export const createFileDownload = (content, filename) => createDownload('data:text/plain;charset=utf-8,' + encodeURIComponent(content), filename);	184✔
530
531	export const getISOStringBoundaries = currentDate => {	184✔
532	const date = [currentDate.getUTCFullYear(), `0${currentDate.getUTCMonth() + 1}`.slice(-2), `0${currentDate.getUTCDate()}`.slice(-2)].join('-');	305✔
533	return { start: `${date}T00:00:00.000`, end: `${date}T23:59:59.999` };	305✔
534	};
535
536	export const isDarkMode = mode => mode === DARK_MODE;	497✔

mendersoftware / gui / 1057188406

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous