908425489

pending completion

Build # 908425489

Build Type

Pull #3799

gitlab-ci

Committed by

mzedel

Commit Message

chore: aligned loader usage in devices list with deployment devices list

Signed-off-by: Manuel Zedel <manuel.zedel@northern.tech>

Pull Request Pull Request #3799: MEN-6553

Run Details

4406 of 6423 branches covered (68.6%)

18 of 19 new or added lines in 3 files covered. (94.74%)

1777 existing lines in 167 files now uncovered.

8329 of 10123 relevant lines covered (82.28%)

144.7 hits per line

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

81.94

/src/js/actions/appActions.js

// 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.
import Cookies from 'universal-cookie';

import GeneralApi from '../api/general-api';
import { getToken } from '../auth';
import {
  SET_ENVIRONMENT_DATA,
  SET_FEATURES,
  SET_FIRST_LOGIN_AFTER_SIGNUP,
  SET_OFFLINE_THRESHOLD,
  SET_SEARCH_STATE,
  SET_SNACKBAR,
  SET_VERSION_INFORMATION,
  TIMEOUTS
} from '../constants/appConstants';
import { DEPLOYMENT_STATES } from '../constants/deploymentConstants';
import { DEVICE_STATES } from '../constants/deviceConstants';
import { onboardingSteps } from '../constants/onboardingConstants';
import { SET_SHOW_HELP } from '../constants/userConstants';
import { deepCompare, extractErrorMessage, preformatWithRequestID, stringToBoolean } from '../helpers';
import { getCurrentUser, getOfflineThresholdSettings, getUserSettings as getUserSettingsSelector } from '../selectors';
import { getOnboardingComponentFor } from '../utils/onboardingmanager';
import { getDeploymentsByStatus } from './deploymentActions';
import {
  getDeviceAttributes,
  getDeviceById,
  getDeviceLimit,
  getDevicesByStatus,
  getDynamicGroups,
  getGroups,
  searchDevices,
  setDeviceListState
} from './deviceActions';
import { setDemoArtifactPort, setOnboardingComplete } from './onboardingActions';
import { getIntegrations, getUserOrganization } from './organizationActions';
import { getReleases } from './releaseActions';
import { getGlobalSettings, getRoles, getUserSettings, saveGlobalSettings, saveUserSettings } from './userActions';

const cookies = new Cookies();

export const commonErrorFallback = 'Please check your connection.';
export const commonErrorHandler = (err, errorContext, dispatch, fallback, mightBeAuthRelated = false) => {
  const errMsg = extractErrorMessage(err, fallback);
  if (mightBeAuthRelated || getToken()) {
    dispatch(setSnackbar(preformatWithRequestID(err.response, `${errorContext} ${errMsg}`), null, 'Copy to clipboard'));
  }
  return Promise.reject(err);
};

const getComparisonCompatibleVersion = version => (isNaN(version.charAt(0)) && version !== 'next' ? 'master' : version);

const featureFlags = [
  'hasAddons',
  'hasAuditlogs',
  'hasMultitenancy',
  'hasDeltaProgress',
  'hasDeviceConfig',
  'hasDeviceConnect',
  'hasReleaseTags',
  'hasReporting',
  'hasMonitor',
  'isEnterprise'
];
export const parseEnvironmentInfo = () => (dispatch, getState) => {
  const state = getState();
  let onboardingComplete = state.onboarding.complete || !!JSON.parse(window.localStorage.getItem('onboardingComplete') ?? 'false');
  let demoArtifactPort = 85;
  let environmentData = {};
  let environmentFeatures = {};
  let versionInfo = {};
  if (mender_environment) {
    const {
      features = {},
      demoArtifactPort: port,
      disableOnboarding,
      hostAddress,
      hostedAnnouncement,
      integrationVersion,
      isDemoMode,
      menderVersion,
      menderArtifactVersion,
      metaMenderVersion,
      recaptchaSiteKey,
      services = {},
      stripeAPIKey,
      trackerCode
    } = mender_environment;
    onboardingComplete = stringToBoolean(features.isEnterprise) || stringToBoolean(disableOnboarding) || onboardingComplete;
    demoArtifactPort = port || demoArtifactPort;
    environmentData = {
      hostedAnnouncement: hostedAnnouncement || state.app.hostedAnnouncement,
      hostAddress: hostAddress || state.app.hostAddress,
      recaptchaSiteKey: recaptchaSiteKey || state.app.recaptchaSiteKey,
      stripeAPIKey: stripeAPIKey || state.app.stripeAPIKey,
      trackerCode: trackerCode || state.app.trackerCode
    };
    environmentFeatures = {
      ...featureFlags.reduce((accu, flag) => ({ ...accu, [flag]: stringToBoolean(features[flag]) }), {}),
      isHosted: stringToBoolean(features.isHosted) || window.location.hostname.includes('hosted.mender.io'),
      isDemoMode: stringToBoolean(isDemoMode || features.isDemoMode)
    };
    versionInfo = {
      docs: isNaN(integrationVersion.charAt(0)) ? '' : integrationVersion.split('.').slice(0, 2).join('.'),
      remainder: {
        Integration: getComparisonCompatibleVersion(integrationVersion),
        'Mender-Client': getComparisonCompatibleVersion(menderVersion),
        'Mender-Artifact': menderArtifactVersion,
        'Meta-Mender': metaMenderVersion,
        Deployments: services.deploymentsVersion,
        Deviceauth: services.deviceauthVersion,
        Inventory: services.inventoryVersion,
        GUI: services.guiVersion
      }
    };
  }
  return Promise.all([
    dispatch(setOnboardingComplete(onboardingComplete)),
    dispatch(setDemoArtifactPort(demoArtifactPort)),
    dispatch({ type: SET_FEATURES, value: environmentFeatures }),
    dispatch({ type: SET_VERSION_INFORMATION, docsVersion: versionInfo.docs, value: versionInfo.remainder }),
    dispatch({ type: SET_ENVIRONMENT_DATA, value: environmentData }),
    dispatch(getLatestReleaseInfo())
  ]);
};

const maybeAddOnboardingTasks = ({ devicesByStatus, dispatch, showHelptips, onboardingState, tasks }) => {
  if (!(showHelptips && onboardingState.showTips) || onboardingState.complete) {
    return tasks;
  }
  const welcomeTip = getOnboardingComponentFor(onboardingSteps.ONBOARDING_START, {
    progress: onboardingState.progress,
    complete: onboardingState.complete,
    showHelptips,
    showTips: onboardingState.showTips
  });
  if (welcomeTip) {
    tasks.push(dispatch(setSnackbar('open', TIMEOUTS.refreshDefault, '', welcomeTip, () => {}, true)));
  }
  // try to retrieve full device details for onboarding devices to ensure ips etc. are available
  // we only load the first few/ 20 devices, as it is possible the onboarding is left dangling
  // and a lot of devices are present and we don't want to flood the backend for this
  return devicesByStatus[DEVICE_STATES.accepted].deviceIds.reduce((accu, id) => {
    accu.push(dispatch(getDeviceById(id)));
    return accu;
  }, tasks);
};

const processUserCookie = (user, showHelptips) => {
  const userCookie = cookies.get(user.id);
  if (userCookie && userCookie.help !== 'undefined') {
    const { help, ...crumbles } = userCookie;
    // got user cookie with pre-existing value
    showHelptips = help;
    // store only remaining cookie values, to allow relying on stored settings from now on
    if (!Object.keys(crumbles).length) {
      cookies.remove(user.id);
    } else {
      cookies.set(user.id, crumbles);
    }
  }
  return showHelptips;
};

export const initializeAppData = () => (dispatch, getState) => {
  let tasks = [
    dispatch(parseEnvironmentInfo()),
    dispatch(getUserSettings()),
    dispatch(getGlobalSettings()),
    dispatch(getDeviceAttributes()),
    dispatch(getDeploymentsByStatus(DEPLOYMENT_STATES.finished, undefined, undefined, undefined, undefined, undefined, undefined, false)),
    dispatch(getDeploymentsByStatus(DEPLOYMENT_STATES.inprogress)),
    dispatch(getDevicesByStatus(DEVICE_STATES.accepted)),
    dispatch(getDevicesByStatus(DEVICE_STATES.pending)),
    dispatch(getDevicesByStatus(DEVICE_STATES.preauth)),
    dispatch(getDevicesByStatus(DEVICE_STATES.rejected)),
    dispatch(getDynamicGroups()),
    dispatch(getGroups()),
    dispatch(getIntegrations()),
    dispatch(getReleases()),
    dispatch(getDeviceLimit()),
    dispatch(getRoles()),
    dispatch(setFirstLoginAfterSignup(cookies.get('firstLoginAfterSignup')))
  ];
  const multitenancy = getState().app.features.hasMultitenancy || getState().app.features.isEnterprise || getState().app.features.isHosted;
  if (multitenancy) {
    tasks.push(dispatch(getUserOrganization()));
  }
  return Promise.all(tasks).then(() => {
    const state = getState();
    const user = getCurrentUser(state);
    let tasks = [];
    let { columnSelection = [], showHelptips = state.users.showHelptips, trackingConsentGiven: hasTrackingEnabled } = getUserSettingsSelector(state);
    tasks.push(dispatch(setDeviceListState({ selectedAttributes: columnSelection.map(column => ({ attribute: column.key, scope: column.scope })) })));
    // checks if user id is set and if cookie for helptips exists for that user
    showHelptips = processUserCookie(user, showHelptips);
    tasks = maybeAddOnboardingTasks({ devicesByStatus: state.devices.byStatus, dispatch, tasks, onboardingState: state.onboarding, showHelptips });
    tasks.push(dispatch({ type: SET_SHOW_HELP, show: showHelptips }));
    let settings = { showHelptips };
    if (cookies.get('_ga') && typeof hasTrackingEnabled === 'undefined') {
      settings.trackingConsentGiven = true;
    }
    tasks.push(dispatch(saveUserSettings(settings)));
    // the following is used as a migration and initialization of the stored identity attribute
    // changing the default device attribute to the first non-deviceId attribute, unless a stored
    // id attribute setting exists
    const identityOptions = state.devices.filteringAttributes.identityAttributes.filter(attribute => !['id', 'Device ID', 'status'].includes(attribute));
    const { id_attribute } = state.users.globalSettings;
    if (!id_attribute && identityOptions.length) {
      tasks.push(dispatch(saveGlobalSettings({ id_attribute: { attribute: identityOptions[0], scope: 'identity' } })));
    } else if (typeof id_attribute === 'string') {
      let attribute = id_attribute;
      if (attribute === 'Device ID') {
        attribute = 'id';
      }
      tasks.push(dispatch(saveGlobalSettings({ id_attribute: { attribute, scope: 'identity' } })));
    }
    return Promise.all(tasks);
  });
};

/*
  General
*/
export const setSnackbar = (message, autoHideDuration, action, children, onClick, onClose) => dispatch =>
  dispatch({
    type: SET_SNACKBAR,
    snackbar: {
      open: message ? true : false,
      message,
      maxWidth: '900px',
      autoHideDuration,
      action,
      children,
      onClick,
      onClose
    }
  });

export const setFirstLoginAfterSignup = firstLoginAfterSignup => dispatch => {
  cookies.set('firstLoginAfterSignup', !!firstLoginAfterSignup, { maxAge: 60, path: '/', domain: '.mender.io', sameSite: false });
  dispatch({ type: SET_FIRST_LOGIN_AFTER_SIGNUP, firstLoginAfterSignup: !!firstLoginAfterSignup });
};

const dateFunctionMap = {
  getDays: 'getDate',
  setDays: 'setDate'
};
export const setOfflineThreshold = () => (dispatch, getState) => {
  const { interval, intervalUnit } = getOfflineThresholdSettings(getState());
  const today = new Date();
  const intervalName = `${intervalUnit.charAt(0).toUpperCase()}${intervalUnit.substring(1)}`;
  const setter = dateFunctionMap[`set${intervalName}`] ?? `set${intervalName}`;
  const getter = dateFunctionMap[`get${intervalName}`] ?? `get${intervalName}`;
  today[setter](today[getter]() - interval);
  let value;
  try {
    value = today.toISOString();
  } catch {
    return Promise.resolve(dispatch(setSnackbar('There was an error saving the offline threshold, please check your settings.')));
  }
  return Promise.resolve(dispatch({ type: SET_OFFLINE_THRESHOLD, value }));
};

export const setVersionInfo = info => (dispatch, getState) =>
  Promise.resolve(
    dispatch({
      type: SET_VERSION_INFORMATION,
      docsVersion: getState().app.docsVersion,
      value: {
        ...getState().app.versionInformation,
        ...info
      }
    })
  );

const versionRegex = new RegExp(/\d+\.\d+/);
const getLatestRelease = thing => {
  const latestKey = Object.keys(thing)
    .filter(key => versionRegex.test(key))
    .sort()
    .reverse()[0];
  return thing[latestKey];
};

const repoKeyMap = {
  integration: 'Integration',
  mender: 'Mender-Client',
  'mender-artifact': 'Mender-Artifact'
};

const deductSaasState = (latestRelease, guiTags, saasReleases) => {
  const latestGuiTag = guiTags[0].name;
  const latestSaasRelease = latestGuiTag.startsWith('saas-v') ? { date: latestGuiTag.split('-v')[1].replaceAll('.', '-'), tag: latestGuiTag } : saasReleases[0];
  return latestSaasRelease.date > latestRelease.release_date ? latestSaasRelease.tag : latestRelease.release;
};

export const getLatestReleaseInfo = () => (dispatch, getState) => {
  if (!getState().app.features.isHosted) {
    return Promise.resolve();
  }
  return Promise.all([GeneralApi.get('/versions.json'), GeneralApi.get('/tags.json')]).then(([{ data }, { data: guiTags }]) => {
    const { releases, saas } = data;
    const latestRelease = getLatestRelease(getLatestRelease(releases));
    const { latestRepos, latestVersions } = latestRelease.repos.reduce(
      (accu, item) => {
        if (repoKeyMap[item.name]) {
          accu.latestVersions[repoKeyMap[item.name]] = getComparisonCompatibleVersion(item.version);
        }
        accu.latestRepos[item.name] = getComparisonCompatibleVersion(item.version);
        return accu;
      },
      { latestVersions: { ...getState().app.versionInformation }, latestRepos: {} }
    );
    const info = deductSaasState(latestRelease, guiTags, saas);
    return Promise.resolve(
      dispatch({
        type: SET_VERSION_INFORMATION,
        docsVersion: getState().app.docsVersion,
        value: {
          ...latestVersions,
          backend: info,
          GUI: info,
          latestRelease: {
            releaseDate: latestRelease.release_date,
            repos: latestRepos
          }
        }
      })
    );
  });
};

export const setSearchState = searchState => (dispatch, getState) => {
  const currentState = getState().app.searchState;
  let nextState = {
    ...currentState,
    ...searchState,
    sort: {
      ...currentState.sort,
      ...searchState.sort
    }
  };
  let tasks = [];
  // eslint-disable-next-line no-unused-vars
  const { isSearching: currentSearching, deviceIds: currentDevices, searchTotal: currentTotal, ...currentRequestState } = currentState;
  // eslint-disable-next-line no-unused-vars
  const { isSearching: nextSearching, deviceIds: nextDevices, searchTotal: nextTotal, ...nextRequestState } = nextState;
  if (nextRequestState.searchTerm && !deepCompare(currentRequestState, nextRequestState)) {
    nextState.isSearching = true;
    tasks.push(
      dispatch(searchDevices(nextState))
        .then(results => {
          const searchResult = results[results.length - 1];
          return dispatch(setSearchState({ ...searchResult, isSearching: false }));
        })
        .catch(() => dispatch(setSearchState({ isSearching: false, searchTotal: 0 })))
    );
  }
  tasks.push(dispatch({ type: SET_SEARCH_STATE, state: nextState }));
  return Promise.all(tasks);
};

1	// Copyright 2019 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 Cookies from 'universal-cookie';
15
16	import GeneralApi from '../api/general-api';
17	import { getToken } from '../auth';
18	import {
19	SET_ENVIRONMENT_DATA,
20	SET_FEATURES,
21	SET_FIRST_LOGIN_AFTER_SIGNUP,
22	SET_OFFLINE_THRESHOLD,
23	SET_SEARCH_STATE,
24	SET_SNACKBAR,
25	SET_VERSION_INFORMATION,
26	TIMEOUTS
27	} from '../constants/appConstants';
28	import { DEPLOYMENT_STATES } from '../constants/deploymentConstants';
29	import { DEVICE_STATES } from '../constants/deviceConstants';
30	import { onboardingSteps } from '../constants/onboardingConstants';
31	import { SET_SHOW_HELP } from '../constants/userConstants';
32	import { deepCompare, extractErrorMessage, preformatWithRequestID, stringToBoolean } from '../helpers';
33	import { getCurrentUser, getOfflineThresholdSettings, getUserSettings as getUserSettingsSelector } from '../selectors';
34	import { getOnboardingComponentFor } from '../utils/onboardingmanager';
35	import { getDeploymentsByStatus } from './deploymentActions';
36	import {
37	getDeviceAttributes,
38	getDeviceById,
39	getDeviceLimit,
40	getDevicesByStatus,
41	getDynamicGroups,
42	getGroups,
43	searchDevices,
44	setDeviceListState
45	} from './deviceActions';
46	import { setDemoArtifactPort, setOnboardingComplete } from './onboardingActions';
47	import { getIntegrations, getUserOrganization } from './organizationActions';
48	import { getReleases } from './releaseActions';
49	import { getGlobalSettings, getRoles, getUserSettings, saveGlobalSettings, saveUserSettings } from './userActions';
50
51	const cookies = new Cookies();	190✔
52
53	export const commonErrorFallback = 'Please check your connection.';	190✔
54	export const commonErrorHandler = (err, errorContext, dispatch, fallback, mightBeAuthRelated = false) => {	190✔
55	const errMsg = extractErrorMessage(err, fallback);	4✔
56	if (mightBeAuthRelated \|\| getToken()) {	4!
57	dispatch(setSnackbar(preformatWithRequestID(err.response, `${errorContext} ${errMsg}`), null, 'Copy to clipboard'));	4✔
58	}
59	return Promise.reject(err);	4✔
60	};
61
62	const getComparisonCompatibleVersion = version => (isNaN(version.charAt(0)) && version !== 'next' ? 'master' : version);	190✔
63
64	const featureFlags = [	190✔
65	'hasAddons',
66	'hasAuditlogs',
67	'hasMultitenancy',
68	'hasDeltaProgress',
69	'hasDeviceConfig',
70	'hasDeviceConnect',
71	'hasReleaseTags',
72	'hasReporting',
73	'hasMonitor',
74	'isEnterprise'
75	];
76	export const parseEnvironmentInfo = () => (dispatch, getState) => {	190✔
77	const state = getState();	11✔
78	let onboardingComplete = state.onboarding.complete \|\| !!JSON.parse(window.localStorage.getItem('onboardingComplete') ?? 'false');	11✔
79	let demoArtifactPort = 85;	11✔
80	let environmentData = {};	11✔
81	let environmentFeatures = {};	11✔
82	let versionInfo = {};	11✔
83	if (mender_environment) {	11!
84	const {
85	features = {},	×
86	demoArtifactPort: port,
87	disableOnboarding,
88	hostAddress,
89	hostedAnnouncement,
90	integrationVersion,
91	isDemoMode,
92	menderVersion,
93	menderArtifactVersion,
94	metaMenderVersion,
95	recaptchaSiteKey,
96	services = {},	×
97	stripeAPIKey,
98	trackerCode
99	} = mender_environment;	11✔
100	onboardingComplete = stringToBoolean(features.isEnterprise) \|\| stringToBoolean(disableOnboarding) \|\| onboardingComplete;	11✔
101	demoArtifactPort = port \|\| demoArtifactPort;	11✔
102	environmentData = {	11✔
103	hostedAnnouncement: hostedAnnouncement \|\| state.app.hostedAnnouncement,	22✔
104	hostAddress: hostAddress \|\| state.app.hostAddress,	22✔
105	recaptchaSiteKey: recaptchaSiteKey \|\| state.app.recaptchaSiteKey,	22✔
106	stripeAPIKey: stripeAPIKey \|\| state.app.stripeAPIKey,	22✔
107	trackerCode: trackerCode \|\| state.app.trackerCode	22✔
108	};
109	environmentFeatures = {	11✔
110	...featureFlags.reduce((accu, flag) => ({ ...accu, [flag]: stringToBoolean(features[flag]) }), {}),	110✔
111	isHosted: stringToBoolean(features.isHosted) \|\| window.location.hostname.includes('hosted.mender.io'),	22✔
112	isDemoMode: stringToBoolean(isDemoMode \|\| features.isDemoMode)	22✔
113	};
114	versionInfo = {	11✔
115	docs: isNaN(integrationVersion.charAt(0)) ? '' : integrationVersion.split('.').slice(0, 2).join('.'),	11!
116	remainder: {
117	Integration: getComparisonCompatibleVersion(integrationVersion),
118	'Mender-Client': getComparisonCompatibleVersion(menderVersion),
119	'Mender-Artifact': menderArtifactVersion,
120	'Meta-Mender': metaMenderVersion,
121	Deployments: services.deploymentsVersion,
122	Deviceauth: services.deviceauthVersion,
123	Inventory: services.inventoryVersion,
124	GUI: services.guiVersion
125	}
126	};
127	}
128	return Promise.all([	11✔
129	dispatch(setOnboardingComplete(onboardingComplete)),
130	dispatch(setDemoArtifactPort(demoArtifactPort)),
131	dispatch({ type: SET_FEATURES, value: environmentFeatures }),
132	dispatch({ type: SET_VERSION_INFORMATION, docsVersion: versionInfo.docs, value: versionInfo.remainder }),
133	dispatch({ type: SET_ENVIRONMENT_DATA, value: environmentData }),
134	dispatch(getLatestReleaseInfo())
135	]);
136	};
137
138	const maybeAddOnboardingTasks = ({ devicesByStatus, dispatch, showHelptips, onboardingState, tasks }) => {	190✔
139	if (!(showHelptips && onboardingState.showTips) \|\| onboardingState.complete) {	4!
140	return tasks;	4✔
141	}
UNCOV 142	const welcomeTip = getOnboardingComponentFor(onboardingSteps.ONBOARDING_START, {	×
143	progress: onboardingState.progress,
144	complete: onboardingState.complete,
145	showHelptips,
146	showTips: onboardingState.showTips
147	});
UNCOV 148	if (welcomeTip) {	×
UNCOV 149	tasks.push(dispatch(setSnackbar('open', TIMEOUTS.refreshDefault, '', welcomeTip, () => {}, true)));	×
150	}
151	// try to retrieve full device details for onboarding devices to ensure ips etc. are available
152	// we only load the first few/ 20 devices, as it is possible the onboarding is left dangling
153	// and a lot of devices are present and we don't want to flood the backend for this
UNCOV 154	return devicesByStatus[DEVICE_STATES.accepted].deviceIds.reduce((accu, id) => {	×
UNCOV 155	accu.push(dispatch(getDeviceById(id)));	×
UNCOV 156	return accu;	×
157	}, tasks);
158	};
159
160	const processUserCookie = (user, showHelptips) => {	190✔
161	const userCookie = cookies.get(user.id);	4✔
162	if (userCookie && userCookie.help !== 'undefined') {	4!
UNCOV 163	const { help, ...crumbles } = userCookie;	×
164	// got user cookie with pre-existing value
UNCOV 165	showHelptips = help;	×
166	// store only remaining cookie values, to allow relying on stored settings from now on
UNCOV 167	if (!Object.keys(crumbles).length) {	×
UNCOV 168	cookies.remove(user.id);	×
169	} else {
UNCOV 170	cookies.set(user.id, crumbles);	×
171	}
172	}
173	return showHelptips;	4✔
174	};
175
176	export const initializeAppData = () => (dispatch, getState) => {	190✔
177	let tasks = [	4✔
178	dispatch(parseEnvironmentInfo()),
179	dispatch(getUserSettings()),
180	dispatch(getGlobalSettings()),
181	dispatch(getDeviceAttributes()),
182	dispatch(getDeploymentsByStatus(DEPLOYMENT_STATES.finished, undefined, undefined, undefined, undefined, undefined, undefined, false)),
183	dispatch(getDeploymentsByStatus(DEPLOYMENT_STATES.inprogress)),
184	dispatch(getDevicesByStatus(DEVICE_STATES.accepted)),
185	dispatch(getDevicesByStatus(DEVICE_STATES.pending)),
186	dispatch(getDevicesByStatus(DEVICE_STATES.preauth)),
187	dispatch(getDevicesByStatus(DEVICE_STATES.rejected)),
188	dispatch(getDynamicGroups()),
189	dispatch(getGroups()),
190	dispatch(getIntegrations()),
191	dispatch(getReleases()),
192	dispatch(getDeviceLimit()),
193	dispatch(getRoles()),
194	dispatch(setFirstLoginAfterSignup(cookies.get('firstLoginAfterSignup')))
195	];
196	const multitenancy = getState().app.features.hasMultitenancy \|\| getState().app.features.isEnterprise \|\| getState().app.features.isHosted;	4✔
197	if (multitenancy) {	4✔
198	tasks.push(dispatch(getUserOrganization()));	3✔
199	}
200	return Promise.all(tasks).then(() => {	4✔
201	const state = getState();	4✔
202	const user = getCurrentUser(state);	4✔
203	let tasks = [];	4✔
204	let { columnSelection = [], showHelptips = state.users.showHelptips, trackingConsentGiven: hasTrackingEnabled } = getUserSettingsSelector(state);	4!
205	tasks.push(dispatch(setDeviceListState({ selectedAttributes: columnSelection.map(column => ({ attribute: column.key, scope: column.scope })) })));	4✔
206	// checks if user id is set and if cookie for helptips exists for that user
207	showHelptips = processUserCookie(user, showHelptips);	4✔
208	tasks = maybeAddOnboardingTasks({ devicesByStatus: state.devices.byStatus, dispatch, tasks, onboardingState: state.onboarding, showHelptips });	4✔
209	tasks.push(dispatch({ type: SET_SHOW_HELP, show: showHelptips }));	4✔
210	let settings = { showHelptips };	4✔
211	if (cookies.get('_ga') && typeof hasTrackingEnabled === 'undefined') {	4!
UNCOV 212	settings.trackingConsentGiven = true;	×
213	}
214	tasks.push(dispatch(saveUserSettings(settings)));	4✔
215	// the following is used as a migration and initialization of the stored identity attribute
216	// changing the default device attribute to the first non-deviceId attribute, unless a stored
217	// id attribute setting exists
218	const identityOptions = state.devices.filteringAttributes.identityAttributes.filter(attribute => !['id', 'Device ID', 'status'].includes(attribute));	5✔
219	const { id_attribute } = state.users.globalSettings;	4✔
220	if (!id_attribute && identityOptions.length) {	4✔
221	tasks.push(dispatch(saveGlobalSettings({ id_attribute: { attribute: identityOptions[0], scope: 'identity' } })));	2✔
222	} else if (typeof id_attribute === 'string') {	2!
UNCOV 223	let attribute = id_attribute;	×
UNCOV 224	if (attribute === 'Device ID') {	×
UNCOV 225	attribute = 'id';	×
226	}
UNCOV 227	tasks.push(dispatch(saveGlobalSettings({ id_attribute: { attribute, scope: 'identity' } })));	×
228	}
229	return Promise.all(tasks);	4✔
230	});
231	};
232
233	/*
234	General
235	*/
236	export const setSnackbar = (message, autoHideDuration, action, children, onClick, onClose) => dispatch =>	190✔
237	dispatch({	118✔
238	type: SET_SNACKBAR,
239	snackbar: {
240	open: message ? true : false,	118✔
241	message,
242	maxWidth: '900px',
243	autoHideDuration,
244	action,
245	children,
246	onClick,
247	onClose
248	}
249	});
250
251	export const setFirstLoginAfterSignup = firstLoginAfterSignup => dispatch => {	190✔
252	cookies.set('firstLoginAfterSignup', !!firstLoginAfterSignup, { maxAge: 60, path: '/', domain: '.mender.io', sameSite: false });	8✔
253	dispatch({ type: SET_FIRST_LOGIN_AFTER_SIGNUP, firstLoginAfterSignup: !!firstLoginAfterSignup });	8✔
254	};
255
256	const dateFunctionMap = {	190✔
257	getDays: 'getDate',
258	setDays: 'setDate'
259	};
260	export const setOfflineThreshold = () => (dispatch, getState) => {	190✔
261	const { interval, intervalUnit } = getOfflineThresholdSettings(getState());	16✔
262	const today = new Date();	16✔
263	const intervalName = `${intervalUnit.charAt(0).toUpperCase()}${intervalUnit.substring(1)}`;	16✔
264	const setter = dateFunctionMap[`set${intervalName}`] ?? `set${intervalName}`;	16✔
265	const getter = dateFunctionMap[`get${intervalName}`] ?? `get${intervalName}`;	16✔
266	today[setter](today[getter]() - interval);	16✔
267	let value;
268	try {	16✔
269	value = today.toISOString();	16✔
270	} catch {
UNCOV 271	return Promise.resolve(dispatch(setSnackbar('There was an error saving the offline threshold, please check your settings.')));	×
272	}
273	return Promise.resolve(dispatch({ type: SET_OFFLINE_THRESHOLD, value }));	16✔
274	};
275
276	export const setVersionInfo = info => (dispatch, getState) =>	190✔
277	Promise.resolve(	2✔
278	dispatch({
279	type: SET_VERSION_INFORMATION,
280	docsVersion: getState().app.docsVersion,
281	value: {
282	...getState().app.versionInformation,
283	...info
284	}
285	})
286	);
287
288	const versionRegex = new RegExp(/\d+\.\d+/);	190✔
289	const getLatestRelease = thing => {	190✔
290	const latestKey = Object.keys(thing)	8✔
291	.filter(key => versionRegex.test(key))	20✔
292	.sort()
293	.reverse()[0];
294	return thing[latestKey];	8✔
295	};
296
297	const repoKeyMap = {	190✔
298	integration: 'Integration',
299	mender: 'Mender-Client',
300	'mender-artifact': 'Mender-Artifact'
301	};
302
303	const deductSaasState = (latestRelease, guiTags, saasReleases) => {	190✔
304	const latestGuiTag = guiTags[0].name;	4✔
305	const latestSaasRelease = latestGuiTag.startsWith('saas-v') ? { date: latestGuiTag.split('-v')[1].replaceAll('.', '-'), tag: latestGuiTag } : saasReleases[0];	4!
306	return latestSaasRelease.date > latestRelease.release_date ? latestSaasRelease.tag : latestRelease.release;	4!
307	};
308
309	export const getLatestReleaseInfo = () => (dispatch, getState) => {	190✔
310	if (!getState().app.features.isHosted) {	15✔
311	return Promise.resolve();	11✔
312	}
313	return Promise.all([GeneralApi.get('/versions.json'), GeneralApi.get('/tags.json')]).then(([{ data }, { data: guiTags }]) => {	4✔
314	const { releases, saas } = data;	4✔
315	const latestRelease = getLatestRelease(getLatestRelease(releases));	4✔
316	const { latestRepos, latestVersions } = latestRelease.repos.reduce(	4✔
317	(accu, item) => {
318	if (repoKeyMap[item.name]) {	20✔
319	accu.latestVersions[repoKeyMap[item.name]] = getComparisonCompatibleVersion(item.version);	12✔
320	}
321	accu.latestRepos[item.name] = getComparisonCompatibleVersion(item.version);	20✔
322	return accu;	20✔
323	},
324	{ latestVersions: { ...getState().app.versionInformation }, latestRepos: {} }
325	);
326	const info = deductSaasState(latestRelease, guiTags, saas);	4✔
327	return Promise.resolve(	4✔
328	dispatch({
329	type: SET_VERSION_INFORMATION,
330	docsVersion: getState().app.docsVersion,
331	value: {
332	...latestVersions,
333	backend: info,
334	GUI: info,
335	latestRelease: {
336	releaseDate: latestRelease.release_date,
337	repos: latestRepos
338	}
339	}
340	})
341	);
342	});
343	};
344
345	export const setSearchState = searchState => (dispatch, getState) => {	190✔
346	const currentState = getState().app.searchState;	11✔
347	let nextState = {	11✔
348	...currentState,
349	...searchState,
350	sort: {
351	...currentState.sort,
352	...searchState.sort
353	}
354	};
355	let tasks = [];	11✔
356	// eslint-disable-next-line no-unused-vars
357	const { isSearching: currentSearching, deviceIds: currentDevices, searchTotal: currentTotal, ...currentRequestState } = currentState;	11✔
358	// eslint-disable-next-line no-unused-vars
359	const { isSearching: nextSearching, deviceIds: nextDevices, searchTotal: nextTotal, ...nextRequestState } = nextState;	11✔
360	if (nextRequestState.searchTerm && !deepCompare(currentRequestState, nextRequestState)) {	11✔
361	nextState.isSearching = true;	2✔
362	tasks.push(	2✔
363	dispatch(searchDevices(nextState))
364	.then(results => {
365	const searchResult = results[results.length - 1];	2✔
366	return dispatch(setSearchState({ ...searchResult, isSearching: false }));	2✔
367	})
UNCOV 368	.catch(() => dispatch(setSearchState({ isSearching: false, searchTotal: 0 })))	×
369	);
370	}
371	tasks.push(dispatch({ type: SET_SEARCH_STATE, state: nextState }));	11✔
372	return Promise.all(tasks);	11✔
373	};

mendersoftware / gui / 908425489

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