@northern.tech/store 0.1.0

package/commonSelectors.ts

@@ -0,0 +1,255 @@
+// 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 { attributeDuplicateFilter, getDemoDeviceAddress as getDemoDeviceAddressHelper } from '@northern.tech/utils/helpers';
+import { createSelector } from '@reduxjs/toolkit';
+
+import { PLANS, defaultReports } from './appSlice/constants';
+import { getFeatures, getSearchedDevices } from './appSlice/selectors';
+import { ALL_DEVICES, ATTRIBUTE_SCOPES, DEVICE_ISSUE_OPTIONS, DEVICE_LIST_MAXIMUM_LENGTH, UNGROUPED_GROUP } from './commonConstants';
+import { getDeploymentsById, getDeploymentsSelectionState, getSelectedDeploymentDeviceIds } from './deploymentsSlice/selectors';
+import { inventoryApiUrlV2, reportingApiUrl } from './devicesSlice/constants';
+import { getDeviceById, getDevicesById, getFilteringAttributes, getGroupsById, getListedDevices } from './devicesSlice/selectors';
+import { getIssueCountsByType } from './monitorSlice/selectors';
+import { onboardingSteps } from './onboardingSlice/constants';
+import { getOnboarding } from './onboardingSlice/selectors';
+import { getAuditLogEntry, getIsServiceProvider, getOrganization } from './organizationSlice/selectors';
+import { getReleasesById } from './releasesSlice/selectors';
+import { rolesByName, uiPermissionsById } from './usersSlice/constants';
+import { getCurrentUser, getGlobalSettings, getRolesById, getUserSettings } from './usersSlice/selectors';
+import { listItemMapper, mapUserRolesToUiPermissions } from './utils';
+
+export const getIsEnterprise = createSelector(
+  [getOrganization, getFeatures],
+  ({ plan = PLANS.os.id }, { isEnterprise, isHosted }) => isEnterprise || (isHosted && plan === PLANS.enterprise.id)
+);
+
+export const getAttrsEndpoint = createSelector([getFeatures], ({ hasReporting }) =>
+  hasReporting ? `${reportingApiUrl}/devices/search/attributes` : `${inventoryApiUrlV2}/filters/attributes`
+);
+export const getSearchEndpoint = createSelector([getFeatures], ({ hasReporting }) =>
+  hasReporting ? `${reportingApiUrl}/devices/search` : `${inventoryApiUrlV2}/filters/search`
+);
+
+export const getUserRoles = createSelector(
+  [getCurrentUser, getRolesById, getIsEnterprise, getFeatures, getOrganization],
+  (currentUser, rolesById, isEnterprise, { isHosted, hasMultitenancy }, { plan = PLANS.os.id }) => {
+    const isAdmin = currentUser.roles?.length
+      ? currentUser.roles.some(role => role === rolesByName.admin)
+      : !(hasMultitenancy || isEnterprise || (isHosted && plan !== PLANS.os.id));
+    const uiPermissions = isAdmin
+      ? mapUserRolesToUiPermissions([rolesByName.admin], rolesById)
+      : mapUserRolesToUiPermissions(currentUser.roles || [], rolesById);
+    return { isAdmin, uiPermissions };
+  }
+);
+
+const hasPermission = (thing, permission) => Object.values(thing).some(permissions => permissions.includes(permission));
+
+export const getUserCapabilities = createSelector([getUserRoles, getIsServiceProvider], ({ uiPermissions }, isServiceProvider) => {
+  const canManageReleases = hasPermission(uiPermissions.releases, uiPermissionsById.manage.value);
+  const canReadReleases = canManageReleases || hasPermission(uiPermissions.releases, uiPermissionsById.read.value);
+  const canUploadReleases = canManageReleases || hasPermission(uiPermissions.releases, uiPermissionsById.upload.value);
+
+  const canAuditlog = uiPermissions.auditlog.includes(uiPermissionsById.read.value);
+
+  const canReadUsers = uiPermissions.userManagement.includes(uiPermissionsById.read.value);
+  const canManageUsers = uiPermissions.userManagement.includes(uiPermissionsById.manage.value);
+
+  const canReadDevices = hasPermission(uiPermissions.groups, uiPermissionsById.read.value);
+  const canWriteDevices = Object.values(uiPermissions.groups).some(
+    groupPermissions => groupPermissions.includes(uiPermissionsById.read.value) && groupPermissions.length > 1
+  );
+  const canTroubleshoot = hasPermission(uiPermissions.groups, uiPermissionsById.connect.value);
+  const canManageDevices = hasPermission(uiPermissions.groups, uiPermissionsById.manage.value);
+  const canConfigure = hasPermission(uiPermissions.groups, uiPermissionsById.configure.value);
+
+  const canDeploy = uiPermissions.deployments.includes(uiPermissionsById.deploy.value) || hasPermission(uiPermissions.groups, uiPermissionsById.deploy.value);
+  const canReadDeployments = uiPermissions.deployments.includes(uiPermissionsById.read.value);
+
+  return {
+    canAuditlog,
+    canConfigure,
+    canDeploy,
+    canManageDevices,
+    canManageReleases,
+    canManageUsers,
+    canReadDeployments,
+    canReadDevices,
+    canReadReleases,
+    canReadUsers,
+    canTroubleshoot,
+    canUploadReleases,
+    canWriteDevices,
+    groupsPermissions: uiPermissions.groups,
+    releasesPermissions: uiPermissions.releases,
+    SPTenant: isServiceProvider
+  };
+});
+
+export const getTenantCapabilities = createSelector(
+  [getFeatures, getOrganization, getIsEnterprise],
+  (
+    { hasAuditlogs: isAuditlogEnabled, hasDeviceConfig: isDeviceConfigEnabled, hasDeviceConnect: isDeviceConnectEnabled, hasMonitor: isMonitorEnabled },
+    { addons = [], plan = PLANS.os.id },
+    isEnterprise
+  ) => {
+    const canDelta = isEnterprise || plan === PLANS.professional.id;
+    const hasAuditlogs = isAuditlogEnabled && isEnterprise;
+    const hasDeviceConfig = isDeviceConfigEnabled && addons.some(addon => addon.name === 'configure' && Boolean(addon.enabled));
+    const hasDeviceConnect = isDeviceConnectEnabled && (!isEnterprise || addons.some(addon => addon.name === 'troubleshoot' && Boolean(addon.enabled)));
+    const hasMonitor = isMonitorEnabled && addons.some(addon => addon.name === 'monitor' && Boolean(addon.enabled));
+    return {
+      canDelta,
+      canRetry: canDelta,
+      canSchedule: canDelta,
+      hasAuditlogs,
+      hasDeviceConfig,
+      hasDeviceConnect,
+      hasFullFiltering: canDelta,
+      hasMonitor,
+      isEnterprise,
+      plan
+    };
+  }
+);
+
+export const getFilterAttributes = createSelector(
+  [getGlobalSettings, getFilteringAttributes],
+  ({ previousFilters }, { identityAttributes, inventoryAttributes, systemAttributes, tagAttributes }) => {
+    const deviceNameAttribute = { key: 'name', value: 'Name', scope: ATTRIBUTE_SCOPES.tags, category: ATTRIBUTE_SCOPES.tags, priority: 1 };
+    const deviceIdAttribute = { key: 'id', value: 'Device ID', scope: ATTRIBUTE_SCOPES.identity, category: ATTRIBUTE_SCOPES.identity, priority: 1 };
+    const checkInAttribute = { key: 'check_in_time', value: 'Latest activity', scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 };
+    const updateAttribute = { ...checkInAttribute, key: 'updated_ts', value: 'Last inventory update' };
+    const firstRequestAttribute = { key: 'created_ts', value: 'First request', scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 };
+    const attributes = [
+      ...previousFilters.map(item => ({
+        ...item,
+        value: deviceIdAttribute.key === item.key ? deviceIdAttribute.value : item.key,
+        category: 'recently used',
+        priority: 0
+      })),
+      deviceNameAttribute,
+      deviceIdAttribute,
+      ...identityAttributes.map(item => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.identity, category: ATTRIBUTE_SCOPES.identity, priority: 1 })),
+      ...inventoryAttributes.map(item => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.inventory, category: ATTRIBUTE_SCOPES.inventory, priority: 2 })),
+      ...tagAttributes.map(item => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.tags, category: ATTRIBUTE_SCOPES.tags, priority: 3 })),
+      checkInAttribute,
+      updateAttribute,
+      firstRequestAttribute,
+      ...systemAttributes.map(item => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 }))
+    ];
+    return attributeDuplicateFilter(attributes, 'key');
+  }
+);
+
+export const getOnboardingState = createSelector([getOnboarding, getUserSettings], ({ complete, progress, showTips, ...remainder }, { onboarding = {} }) => ({
+  ...remainder,
+  ...onboarding,
+  complete: onboarding.complete || complete,
+  progress:
+    Object.keys(onboardingSteps).findIndex(step => step === progress) > Object.keys(onboardingSteps).findIndex(step => step === onboarding.progress)
+      ? progress
+      : onboarding.progress,
+  showTips: !onboarding.showTips ? onboarding.showTips : showTips
+}));
+
+export const getDemoDeviceAddress = createSelector([getDevicesById, getOnboarding], (devicesById, { approach, demoArtifactPort }) => {
+  const demoDeviceAddress = `http://${getDemoDeviceAddressHelper(Object.values(devicesById), approach)}`;
+  return demoArtifactPort ? `${demoDeviceAddress}:${demoArtifactPort}` : demoDeviceAddress;
+});
+
+export const getDeviceConfigDeployment = createSelector([getDeviceById, getDeploymentsById], (device, deploymentsById) => {
+  const { config = {} } = device;
+  const { deployment_id: configDeploymentId } = config;
+  const deviceConfigDeployment = deploymentsById[configDeploymentId] || {};
+  return { device, deviceConfigDeployment };
+});
+
+export const getDeploymentRelease = createSelector(
+  [getDeploymentsById, getDeploymentsSelectionState, getReleasesById],
+  (deploymentsById, { selectedId }, releasesById) => {
+    const deployment = deploymentsById[selectedId] || {};
+    return deployment.artifact_name && releasesById[deployment.artifact_name] ? releasesById[deployment.artifact_name] : { device_types_compatible: [] };
+  }
+);
+
+export const getSelectedDeploymentData = createSelector(
+  [getDeploymentsById, getDeploymentsSelectionState, getDevicesById, getSelectedDeploymentDeviceIds],
+  (deploymentsById, { selectedId }, devicesById, selectedDeviceIds) => {
+    const deployment = deploymentsById[selectedId] ?? {};
+    const { devices = {} } = deployment;
+    return {
+      deployment,
+      selectedDevices: selectedDeviceIds.map(deviceId => ({ ...devicesById[deviceId], ...devices[deviceId] }))
+    };
+  }
+);
+
+export const getAvailableIssueOptionsByType = createSelector(
+  [getFeatures, getTenantCapabilities, getIssueCountsByType],
+  ({ hasReporting }, { hasFullFiltering, hasMonitor }, issueCounts) =>
+    Object.values(DEVICE_ISSUE_OPTIONS).reduce((accu, { isCategory, key, needsFullFiltering, needsMonitor, needsReporting, title }) => {
+      if (isCategory || (needsReporting && !hasReporting) || (needsFullFiltering && !hasFullFiltering) || (needsMonitor && !hasMonitor)) {
+        return accu;
+      }
+      accu[key] = { count: issueCounts[key].filtered, key, title };
+      return accu;
+    }, {})
+);
+
+export const getGroupNames = createSelector([getGroupsById, getUserRoles, (_, options = {}) => options], (groupsById, { uiPermissions }, { staticOnly }) => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { [UNGROUPED_GROUP.id]: ungrouped, ...groups } = groupsById;
+  if (staticOnly) {
+    return Object.keys(uiPermissions.groups).sort();
+  }
+  return Object.keys(
+    Object.entries(groups).reduce((accu, [groupName, group]) => {
+      if (group.filterId || uiPermissions.groups[ALL_DEVICES]) {
+        accu[groupName] = group;
+      }
+      return accu;
+    }, uiPermissions.groups)
+  ).sort();
+});
+
+export const getDeviceReportsForUser = createSelector(
+  [getUserSettings, getCurrentUser, getGlobalSettings, getDevicesById],
+  ({ reports }, { id: currentUserId }, globalSettings, devicesById) => {
+    return reports || globalSettings[`${currentUserId}-reports`] || (Object.keys(devicesById).length ? defaultReports : []);
+  }
+);
+
+const listTypeDeviceIdMap = {
+  deviceList: getListedDevices,
+  search: getSearchedDevices
+};
+const deviceMapDefault = { defaultObject: { auth_sets: [] }, cutOffSize: DEVICE_LIST_MAXIMUM_LENGTH };
+const getDeviceMappingDefaults = () => deviceMapDefault;
+
+export const getMappedDevicesList = createSelector(
+  [getDevicesById, (state, listType) => listTypeDeviceIdMap[listType](state), getDeviceMappingDefaults],
+  listItemMapper
+);
+
+export const getAuditlogDevice = createSelector([getAuditLogEntry, getDevicesById], (auditlogEvent, devicesById) => {
+  let auditlogDevice = {};
+  if (auditlogEvent) {
+    const { object = {} } = auditlogEvent;
+    const { device = {}, id, type } = object;
+    auditlogDevice = type === 'device' ? { id, ...device } : auditlogDevice;
+  }
+  return { ...auditlogDevice, ...devicesById[auditlogDevice.id] };
+});

package/constants.ts

@@ -0,0 +1,22 @@
+// 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.
+export * from './appSlice/constants';
+export * from './commonConstants';
+export * from './deploymentsSlice/constants';
+export * from './devicesSlice/constants';
+export * from './monitorSlice/constants';
+export * from './onboardingSlice/constants';
+export * from './organizationSlice/constants';
+export * from './releasesSlice/constants';
+export * from './usersSlice/constants';

package/deploymentsSlice/constants.ts

@@ -0,0 +1,175 @@
+// 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 { DEVICE_LIST_DEFAULTS, SORTING_OPTIONS, apiUrl } from '@northern.tech/store/constants';
+
+const alreadyInstalled = 'already-installed';
+
+export const deploymentsApiUrl = `${apiUrl.v1}/deployments`;
+export const deploymentsApiUrlV2 = `${apiUrl.v2}/deployments`;
+
+export const deploymentSubstates = {
+  aborted: 'aborted',
+  alreadyInstalled,
+  decommissioned: 'decommissioned',
+  downloading: 'downloading',
+  failure: 'failure',
+  installing: 'installing',
+  noartifact: 'noartifact',
+  pause_before_committing: 'pause_before_committing',
+  pause_before_installing: 'pause_before_installing',
+  pause_before_rebooting: 'pause_before_rebooting',
+  pending: 'pending',
+  rebooting: 'rebooting',
+  success: 'success'
+};
+
+export const deploymentStatesToSubstates = {
+  failures: [deploymentSubstates.failure, deploymentSubstates.aborted, deploymentSubstates.decommissioned],
+  inprogress: [deploymentSubstates.downloading, deploymentSubstates.installing, deploymentSubstates.rebooting],
+  paused: [deploymentSubstates.pause_before_installing, deploymentSubstates.pause_before_rebooting, deploymentSubstates.pause_before_committing],
+  pending: [deploymentSubstates.pending],
+  successes: [deploymentSubstates.success, deploymentSubstates.alreadyInstalled, deploymentSubstates.noartifact]
+};
+
+export const deploymentStatesToSubstatesWithSkipped = {
+  ...deploymentStatesToSubstates,
+  failures: [deploymentSubstates.failure],
+  skipped: [deploymentSubstates.aborted, deploymentSubstates.noartifact, deploymentSubstates.alreadyInstalled, deploymentSubstates.decommissioned],
+  successes: [deploymentSubstates.success]
+};
+export const installationSubstatesMap = {
+  download: {
+    title: 'download',
+    done: 'downloaded',
+    successIndicators: [deploymentSubstates.installing, deploymentSubstates.rebooting, ...deploymentStatesToSubstates.paused, deploymentSubstates.success],
+    failureIndicators: deploymentStatesToSubstates.failures,
+    pauseConfigurationIndicator: 'ArtifactInstall_Enter'
+  },
+  install: {
+    title: 'install',
+    done: 'installed',
+    successIndicators: [
+      deploymentSubstates.rebooting,
+      deploymentSubstates.pause_before_rebooting,
+      deploymentSubstates.pause_before_committing,
+      deploymentSubstates.success
+    ],
+    failureIndicators: deploymentStatesToSubstates.failures,
+    pauseConfigurationIndicator: 'ArtifactReboot_Enter'
+  },
+  reboot: {
+    title: 'reboot',
+    done: 'rebooted',
+    successIndicators: [deploymentSubstates.pause_before_committing, deploymentSubstates.success],
+    failureIndicators: deploymentStatesToSubstates.failures,
+    pauseConfigurationIndicator: 'ArtifactCommit_Enter'
+  },
+  commit: {
+    title: 'commit',
+    done: 'committed',
+    successIndicators: deploymentStatesToSubstates.successes,
+    failureIndicators: deploymentStatesToSubstates.failures,
+    pauseConfigurationIndicator: undefined
+  }
+};
+
+export const DEPLOYMENT_STATES = {
+  finished: 'finished',
+  inprogress: 'inprogress',
+  pending: 'pending',
+  scheduled: 'scheduled'
+};
+
+export const listDefaultsByState = {
+  [DEPLOYMENT_STATES.inprogress]: { page: 1, perPage: 10 },
+  [DEPLOYMENT_STATES.pending]: { page: 1, perPage: 10 },
+  [DEPLOYMENT_STATES.scheduled]: { ...DEVICE_LIST_DEFAULTS },
+  [DEPLOYMENT_STATES.finished]: { ...DEVICE_LIST_DEFAULTS },
+  sort: { direction: SORTING_OPTIONS.desc }
+};
+
+export const DEFAULT_PENDING_INPROGRESS_COUNT = 10;
+export const DEPLOYMENT_ROUTES = {
+  active: {
+    key: 'active',
+    route: '/deployments/active',
+    states: [DEPLOYMENT_STATES.pending, DEPLOYMENT_STATES.inprogress],
+    title: 'Active'
+  },
+  finished: {
+    key: 'finished',
+    route: '/deployments/finished',
+    states: [DEPLOYMENT_STATES.finished],
+    title: 'Finished'
+  },
+  scheduled: {
+    key: 'scheduled',
+    route: '/deployments/scheduled',
+    states: [DEPLOYMENT_STATES.scheduled],
+    title: 'Scheduled'
+  }
+};
+export const DEPLOYMENT_TYPES = {
+  software: 'software',
+  configuration: 'configuration'
+};
+export const defaultStats = {
+  [deploymentSubstates.aborted]: 0,
+  [deploymentSubstates.alreadyInstalled]: 0,
+  [deploymentSubstates.decommissioned]: 0,
+  [deploymentSubstates.downloading]: 0,
+  [deploymentSubstates.failure]: 0,
+  [deploymentSubstates.installing]: 0,
+  [deploymentSubstates.noartifact]: 0,
+  [deploymentSubstates.pause_before_committing]: 0,
+  [deploymentSubstates.pause_before_installing]: 0,
+  [deploymentSubstates.pause_before_rebooting]: 0,
+  [deploymentSubstates.pending]: 0,
+  [deploymentSubstates.rebooting]: 0,
+  [deploymentSubstates.success]: 0
+};
+export const deploymentDisplayStates = {
+  finished: 'Finished',
+  scheduled: 'Scheduled',
+  skipped: 'Skipped',
+  paused: 'Paused',
+  pending: 'Pending',
+  inprogress: 'In Progress',
+  success: 'Success',
+  successes: 'Success',
+  failure: 'Fail',
+  failures: 'Fail'
+};
+
+export const deploymentPrototype = {
+  devices: {},
+  name: undefined,
+  statistics: { status: {} }
+};
+
+export const pauseMap = {
+  [deploymentSubstates.pause_before_installing]: {
+    title: installationSubstatesMap.download.done,
+    followUp: installationSubstatesMap.download.pauseConfigurationIndicator
+  },
+  [deploymentSubstates.pause_before_rebooting]: {
+    title: installationSubstatesMap.install.done,
+    followUp: installationSubstatesMap.install.pauseConfigurationIndicator
+  },
+  [deploymentSubstates.pause_before_committing]: {
+    title: installationSubstatesMap.reboot.done,
+    followUp: installationSubstatesMap.reboot.pauseConfigurationIndicator
+  }
+};
+export const limitDefault = { min: 5, max: 100, default: 10 };

package/deploymentsSlice/index.ts

@@ -0,0 +1,145 @@
+// Copyright 2023 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 { DEVICE_LIST_DEFAULTS } from '@northern.tech/store/constants';
+import { createSlice } from '@reduxjs/toolkit';
+
+import { DEFAULT_PENDING_INPROGRESS_COUNT, DEPLOYMENT_ROUTES, DEPLOYMENT_STATES, deploymentPrototype, limitDefault } from './constants';
+
+export const sliceName = 'deployments';
+
+export const initialState = {
+  byId: {
+    // [id]: { statistics: { status: {}, total_size }, devices: { [deploymentId]: { id, log } }, totalDeviceCount }
+  },
+  byStatus: {
+    finished: { deploymentIds: [], total: 0 },
+    inprogress: { deploymentIds: [], total: 0 },
+    pending: { deploymentIds: [], total: 0 },
+    scheduled: { deploymentIds: [], total: 0 }
+  },
+  config: {
+    binaryDelta: {
+      timeout: -1,
+      duplicatesWindow: -1,
+      compressionLevel: -1,
+      disableChecksum: false,
+      disableDecompression: false,
+      inputWindow: -1,
+      instructionBuffer: -1,
+      sourceWindow: -1
+    },
+    binaryDeltaLimits: {
+      timeout: { ...limitDefault, default: 60, max: 3600, min: 60 },
+      sourceWindow: limitDefault,
+      inputWindow: limitDefault,
+      duplicatesWindow: limitDefault,
+      instructionBuffer: limitDefault
+    }
+  },
+  deploymentDeviceLimit: 5000,
+  selectedDeviceIds: [],
+  selectionState: {
+    finished: { ...DEVICE_LIST_DEFAULTS, endDate: undefined, search: '', selection: [], startDate: undefined, total: 0, type: '' },
+    inprogress: { ...DEVICE_LIST_DEFAULTS, perPage: DEFAULT_PENDING_INPROGRESS_COUNT, selection: [] },
+    pending: { ...DEVICE_LIST_DEFAULTS, perPage: DEFAULT_PENDING_INPROGRESS_COUNT, selection: [] },
+    scheduled: { ...DEVICE_LIST_DEFAULTS, selection: [] },
+    general: {
+      state: DEPLOYMENT_ROUTES.active.key,
+      showCreationDialog: false,
+      showReportDialog: false,
+      reportType: null // DeploymentConstants.DEPLOYMENT_TYPES.configuration|DeploymentConstants.DEPLOYMENT_TYPES.software
+    },
+    selectedId: undefined
+  }
+};
+
+export const deploymentsSlice = createSlice({
+  name: sliceName,
+  initialState,
+  reducers: {
+    createdDeployment: (state, action) => {
+      state.byId[action.payload.id] = {
+        ...deploymentPrototype,
+        ...action.payload
+      };
+      state.byStatus[DEPLOYMENT_STATES.pending].total = state.byStatus[DEPLOYMENT_STATES.pending].total + 1;
+      state.byStatus[DEPLOYMENT_STATES.pending].deploymentIds = [...state.byStatus.pending.deploymentIds, action.payload.id];
+      (state.selectionState[DEPLOYMENT_STATES.pending].selection = [action.payload.id, ...state.selectionState[DEPLOYMENT_STATES.pending].selection]),
+        (state.selectionState[DEPLOYMENT_STATES.pending].total = state.selectionState[DEPLOYMENT_STATES.pending].total + 1);
+    },
+    removedDeployment: (state, action) => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { [action.payload]: removedDeployment, ...remainder } = state.byId;
+      state.byId = remainder;
+    },
+    receivedDeployment: (state, action) => {
+      state.byId[action.payload.id] = {
+        ...(state.byId[action.payload.id] || {}),
+        ...action.payload
+      };
+    },
+    receivedDeploymentDeviceLog: (state, action) => {
+      const { id, deviceId, log } = action.payload;
+      const deployment = {
+        ...deploymentPrototype,
+        ...state.byId[id]
+      };
+      state.byId[id] = {
+        ...deployment,
+        devices: {
+          ...deployment.devices,
+          [deviceId]: {
+            ...deployment.devices[deviceId],
+            log
+          }
+        }
+      };
+    },
+    receivedDeploymentDevices: (state, action) => {
+      const { id, devices, selectedDeviceIds, totalDeviceCount } = action.payload;
+      state.byId[id] = {
+        ...state.byId[id],
+        devices,
+        totalDeviceCount
+      };
+      state.selectedDeviceIds = selectedDeviceIds;
+    },
+    receivedDeployments: (state, action) => {
+      state.byId = {
+        ...state.byId,
+        ...action.payload
+      };
+    },
+    receivedDeploymentsForStatus: (state, action) => {
+      const { status, deploymentIds, total } = action.payload;
+      state.byStatus[status].deploymentIds = deploymentIds;
+      state.byStatus[status].total = total;
+    },
+    selectDeploymentsForStatus: (state, action) => {
+      const { status, deploymentIds, total } = action.payload;
+      state.selectionState[status].selection = deploymentIds;
+      state.selectionState[status].total = total;
+    },
+    setDeploymentsState: (state, action) => {
+      state.selectionState = action.payload;
+    },
+    setDeploymentsConfig: (state, action) => {
+      state.config = action.payload;
+    }
+  }
+});
+
+export const actions = deploymentsSlice.actions;
+export default deploymentsSlice.reducer;