@northern.tech/store 0.1.0

package/onboardingSlice/thunks.test.ts

@@ -0,0 +1,235 @@
+// Copyright 2020 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 { getUserSettings, saveUserSettings } from '@northern.tech/store/thunks';
+import configureMockStore from 'redux-mock-store';
+import { thunk } from 'redux-thunk';
+
+import { actions } from '.';
+import { defaultState } from '../../../../tests/mockData';
+import { actions as userActions } from '../usersSlice';
+import { onboardingSteps } from './constants';
+import { advanceOnboarding, getOnboardingState, setOnboardingApproach, setOnboardingCanceled, setOnboardingComplete, setOnboardingDeviceType } from './thunks';
+
+const middlewares = [thunk];
+const mockStore = configureMockStore(middlewares);
+
+export const defaultOnboardingState = {
+  approach: null,
+  complete: false,
+  demoArtifactPort: 85,
+  deviceType: null,
+  progress: undefined,
+  showConnectDeviceDialog: false,
+  showTips: undefined,
+  showTipsDialog: false,
+  something: 'here'
+};
+
+export const expectedOnboardingActions = [
+  { type: getOnboardingState.pending.type },
+  { type: actions.setOnboardingComplete.type, payload: false },
+  {
+    type: actions.setOnboardingState.type,
+    payload: {
+      ...defaultOnboardingState,
+      address: 'http://192.168.10.141:85',
+      approach: 'physical',
+      deviceType: ['raspberrypi4'],
+      progress: 'devices-accepted-onboarding',
+      showTips: true
+    }
+  },
+  { type: saveUserSettings.pending.type },
+  { type: getUserSettings.pending.type },
+  { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings } },
+  { type: getUserSettings.fulfilled.type },
+  {
+    type: userActions.setUserSettings.type,
+    payload: {
+      ...defaultState.users.userSettings,
+      onboarding: {
+        ...defaultOnboardingState,
+        address: 'http://192.168.10.141:85',
+        approach: 'physical',
+        deviceType: ['raspberrypi4'],
+        progress: 'devices-accepted-onboarding',
+        showTips: true
+      }
+    }
+  },
+  { type: saveUserSettings.fulfilled.type },
+  { type: getOnboardingState.fulfilled.type }
+];
+
+describe('onboarding actions', () => {
+  it('should pass on onboarding completion', async () => {
+    const store = mockStore({ ...defaultState });
+    await store.dispatch(setOnboardingComplete(true));
+    const expectedActions = [
+      { type: setOnboardingComplete.pending.type },
+      { type: actions.setOnboardingComplete.type, payload: true },
+      { type: actions.setShowOnboardingHelp.type, payload: false },
+      { type: advanceOnboarding.pending.type },
+      { type: actions.setOnboardingProgress.type, payload: onboardingSteps.DEPLOYMENTS_PAST_COMPLETED_FAILURE },
+      { type: saveUserSettings.pending.type },
+      { type: getUserSettings.pending.type },
+      { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings } },
+      { type: getUserSettings.fulfilled.type },
+      {
+        type: userActions.setUserSettings.type,
+        payload: {
+          ...defaultState.users.userSettings,
+          onboarding: {
+            ...defaultOnboardingState,
+            complete: true,
+            progress: onboardingSteps.DEPLOYMENTS_PAST_COMPLETED_FAILURE
+          }
+        }
+      },
+      { type: saveUserSettings.fulfilled.type },
+      { type: advanceOnboarding.fulfilled.type },
+      { type: setOnboardingComplete.fulfilled.type }
+    ];
+    const storeActions = store.getActions();
+    expect(storeActions.length).toEqual(expectedActions.length);
+    expectedActions.map((action, index) => Object.keys(action).map(key => expect(storeActions[index][key]).toEqual(action[key])));
+  });
+  it('should pass on onboarding approach', async () => {
+    const store = mockStore({ ...defaultState });
+    await store.dispatch(setOnboardingApproach('test'));
+    const expectedActions = [
+      { type: setOnboardingApproach.pending.type },
+      { type: actions.setOnboardingApproach.type, payload: 'test' },
+      { type: saveUserSettings.pending.type },
+      { type: getUserSettings.pending.type },
+      { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings } },
+      { type: getUserSettings.fulfilled.type },
+      {
+        type: userActions.setUserSettings.type,
+        payload: {
+          ...defaultState.users.userSettings,
+          onboarding: {
+            ...defaultOnboardingState,
+            approach: 'test'
+          }
+        }
+      },
+      { type: saveUserSettings.fulfilled.type },
+      { type: setOnboardingApproach.fulfilled.type }
+    ];
+    const storeActions = store.getActions();
+    expect(storeActions.length).toEqual(expectedActions.length);
+    expectedActions.map((action, index) => Object.keys(action).map(key => expect(storeActions[index][key]).toEqual(action[key])));
+  });
+  it('should pass on onboarding device type', async () => {
+    const store = mockStore({ ...defaultState });
+    await store.dispatch(setOnboardingDeviceType('testtype'));
+    const expectedActions = [
+      { type: setOnboardingDeviceType.pending.type },
+      { type: actions.setOnboardingDeviceType.type, payload: 'testtype' },
+      { type: saveUserSettings.pending.type },
+      { type: getUserSettings.pending.type },
+      { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings } },
+      { type: getUserSettings.fulfilled.type },
+      {
+        type: userActions.setUserSettings.type,
+        payload: {
+          ...defaultState.users.userSettings,
+          columnSelection: [],
+          onboarding: {
+            ...defaultOnboardingState,
+            deviceType: 'testtype'
+          }
+        }
+      },
+      { type: saveUserSettings.fulfilled.type },
+      { type: setOnboardingDeviceType.fulfilled.type }
+    ];
+    const storeActions = store.getActions();
+    expect(storeActions.length).toEqual(expectedActions.length);
+    expectedActions.map((action, index) => Object.keys(action).map(key => expect(storeActions[index][key]).toEqual(action[key])));
+  });
+  it('should advance onboarding by one step', async () => {
+    const store = mockStore({ ...defaultState });
+    await store.dispatch(advanceOnboarding(onboardingSteps.DASHBOARD_ONBOARDING_START));
+    const expectedActions = [
+      { type: advanceOnboarding.pending.type },
+      { type: actions.setOnboardingProgress.type, payload: onboardingSteps.DEVICES_PENDING_ONBOARDING_START },
+      { type: saveUserSettings.pending.type },
+      { type: getUserSettings.pending.type },
+      { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings } },
+      { type: getUserSettings.fulfilled.type },
+      {
+        type: userActions.setUserSettings.type,
+        payload: {
+          ...defaultState.users.userSettings,
+          columnSelection: [],
+          onboarding: {
+            ...defaultOnboardingState,
+            progress: onboardingSteps.DEVICES_PENDING_ONBOARDING_START
+          }
+        }
+      },
+      { type: saveUserSettings.fulfilled.type },
+      { type: advanceOnboarding.fulfilled.type }
+    ];
+    const storeActions = store.getActions();
+    expect(storeActions.length).toEqual(expectedActions.length);
+    expectedActions.map((action, index) => Object.keys(action).map(key => expect(storeActions[index][key]).toEqual(action[key])));
+  });
+  it('should disable helptips and store a canceled state', async () => {
+    const store = mockStore({ ...defaultState });
+    await store.dispatch(setOnboardingCanceled());
+    const expectedActions = [
+      { type: setOnboardingCanceled.pending.type },
+      { type: actions.setShowOnboardingHelp.type, payload: false },
+      { type: actions.setShowDismissOnboardingTipsDialog.type, payload: false },
+      { type: actions.setOnboardingComplete.type, payload: true },
+      { type: advanceOnboarding.pending.type },
+      { type: actions.setOnboardingProgress.type, payload: 'onboarding-canceled' },
+      { type: saveUserSettings.pending.type },
+      { type: getUserSettings.pending.type },
+      { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings } },
+      { type: getUserSettings.fulfilled.type },
+      {
+        type: userActions.setUserSettings.type,
+        payload: {
+          ...defaultState.users.userSettings,
+          columnSelection: [],
+          onboarding: {
+            ...defaultOnboardingState,
+            complete: true,
+            progress: 'onboarding-canceled'
+          }
+        }
+      },
+      { type: saveUserSettings.fulfilled.type },
+      { type: advanceOnboarding.fulfilled.type },
+      { type: setOnboardingCanceled.fulfilled.type }
+    ];
+    const storeActions = store.getActions();
+    expect(storeActions.length).toEqual(expectedActions.length);
+    expectedActions.map((action, index) => Object.keys(action).map(key => expect(storeActions[index][key]).toEqual(action[key])));
+  });
+  it('should try to derive the onboarding state based on the stored state of the environment', async () => {
+    const store = mockStore({ ...defaultState });
+    const stepNames = Object.keys(onboardingSteps);
+    await store.dispatch(getOnboardingState(stepNames[0]));
+    const expectedActions = expectedOnboardingActions;
+    const storeActions = store.getActions();
+    expect(storeActions.length).toEqual(expectedActions.length);
+    expectedActions.map((action, index) => Object.keys(action).map(key => expect(storeActions[index][key]).toEqual(action[key])));
+  });
+});

package/onboardingSlice/thunks.ts

@@ -0,0 +1,142 @@
+// Copyright 2020 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_STATES, onboardingSteps as onboardingStepNames, orderedOnboardingSteps as onboardingSteps } from '@northern.tech/store/constants';
+import { getOnboardingState as getCurrentOnboardingState, getUserCapabilities } from '@northern.tech/store/selectors';
+import { saveUserSettings } from '@northern.tech/store/thunks';
+import { getDemoDeviceAddress } from '@northern.tech/utils/helpers';
+import { createAsyncThunk } from '@reduxjs/toolkit';
+import Cookies from 'universal-cookie';
+
+import { actions, sliceName } from '.';
+
+const cookies = new Cookies();
+
+export const applyOnboardingFallbacks = progress => {
+  const step = onboardingSteps[progress];
+  if (step && step.fallbackStep) {
+    return step.fallbackStep;
+  }
+  return progress;
+};
+
+const determineProgress = (acceptedDevices, pendingDevices, releases, pastDeployments) => {
+  const steps = onboardingSteps;
+  let progress = -1;
+  progress = pendingDevices.length > 1 ? steps.findIndex(step => step === onboardingStepNames.DEVICES_PENDING_ACCEPTING_ONBOARDING) : progress;
+  progress = acceptedDevices.length >= 1 ? steps.findIndex(step => step === onboardingStepNames.DEVICES_ACCEPTED_ONBOARDING) : progress;
+  progress =
+    acceptedDevices.length > 1 && releases.length > 1 && pastDeployments.length > 1
+      ? steps.findIndex(step => step === onboardingStepNames.DEPLOYMENTS_PAST_COMPLETED)
+      : progress;
+  return steps[progress];
+};
+
+const deductOnboardingState = ({ devicesById, devicesByStatus, onboardingState, pastDeployments, releases, userCapabilities, userId }) => {
+  const { canDeploy, canManageDevices, canReadDeployments, canReadDevices, canReadReleases, canUploadReleases } = userCapabilities;
+  const userCookie = cookies.get(`${userId}-onboarded`);
+  const acceptedDevices = devicesByStatus[DEVICE_STATES.accepted].deviceIds;
+  const pendingDevices = devicesByStatus[DEVICE_STATES.pending].deviceIds;
+  let deviceType = onboardingState.deviceType ?? [];
+  deviceType =
+    !deviceType.length && acceptedDevices.length && devicesById[acceptedDevices[0]].hasOwnProperty('attributes')
+      ? devicesById[acceptedDevices[0]].attributes.device_type
+      : deviceType;
+  const progress = applyOnboardingFallbacks(onboardingState.progress || determineProgress(acceptedDevices, pendingDevices, releases, pastDeployments));
+  return {
+    ...onboardingState,
+    complete: !!(
+      Boolean(userCookie) ||
+      onboardingState.complete ||
+      (acceptedDevices.length > 1 && pendingDevices.length > 0 && releases.length > 1 && pastDeployments.length > 1) ||
+      (acceptedDevices.length >= 1 && releases.length >= 2 && pastDeployments.length > 2) ||
+      (acceptedDevices.length >= 1 && pendingDevices.length > 0 && releases.length >= 2 && pastDeployments.length >= 2) ||
+      onboardingSteps.findIndex(step => step === progress) >= onboardingSteps.length - 1 ||
+      onboardingState.disable ||
+      ![canDeploy, canManageDevices, canReadDeployments, canReadDevices, canReadReleases, canUploadReleases].every(i => i)
+    ),
+    showTips: onboardingState.showTips != null ? onboardingState.showTips : true,
+    deviceType,
+    approach: onboardingState.approach || (deviceType.some(type => type.startsWith('qemu')) ? 'virtual' : 'physical'),
+    progress
+  };
+};
+
+export const getOnboardingState = createAsyncThunk(`${sliceName}/getOnboardingState`, (_, { dispatch, getState }) => {
+  const state = getState();
+  let onboardingState = getCurrentOnboardingState(state);
+  if (!onboardingState.complete) {
+    const userId = state.users.currentUser;
+    onboardingState = deductOnboardingState({
+      devicesById: state.devices.byId,
+      devicesByStatus: state.devices.byStatus,
+      onboardingState,
+      pastDeployments: state.deployments.byStatus.finished.deploymentIds,
+      releases: Object.values(state.releases.byId),
+      userCapabilities: getUserCapabilities(state),
+      userId
+    });
+  }
+  onboardingState.progress = onboardingState.progress || onboardingStepNames.DASHBOARD_ONBOARDING_START;
+  const demoDeviceAddress = `http://${getDemoDeviceAddress(Object.values(state.devices.byId), onboardingState.approach)}`;
+  onboardingState.address = state.onboarding.demoArtifactPort ? `${demoDeviceAddress}:${state.onboarding.demoArtifactPort}` : demoDeviceAddress;
+  return Promise.all([
+    dispatch(actions.setOnboardingComplete(onboardingState.complete)),
+    dispatch(actions.setOnboardingState(onboardingState)),
+    dispatch(saveUserSettings({ onboarding: onboardingState }))
+  ]);
+});
+
+export const setOnboardingDeviceType = createAsyncThunk(`${sliceName}/setOnboardingDeviceType`, (value, { dispatch }) =>
+  Promise.all([dispatch(actions.setOnboardingDeviceType(value)), dispatch(saveUserSettings({ onboarding: { deviceType: value } }))])
+);
+
+export const setOnboardingApproach = createAsyncThunk(`${sliceName}/setOnboardingApproach`, (value, { dispatch }) =>
+  Promise.all([dispatch(actions.setOnboardingApproach(value)), dispatch(saveUserSettings({ onboarding: { approach: value } }))])
+);
+
+export const setOnboardingComplete = createAsyncThunk(`${sliceName}/setOnboardingComplete`, (value, { dispatch }) => {
+  let tasks = [Promise.resolve(dispatch(actions.setOnboardingComplete(value)))];
+  if (value) {
+    tasks.push(Promise.resolve(dispatch(actions.setShowOnboardingHelp(false))));
+    tasks.push(Promise.resolve(dispatch(advanceOnboarding(onboardingStepNames.DEPLOYMENTS_PAST_COMPLETED))));
+  }
+  return Promise.all(tasks);
+});
+
+export const setOnboardingCanceled = createAsyncThunk(`${sliceName}/setOnboardingCanceled`, (_, { dispatch }) =>
+  Promise.all([
+    Promise.resolve(dispatch(actions.setShowOnboardingHelp(false))),
+    Promise.resolve(dispatch(actions.setShowDismissOnboardingTipsDialog(false))),
+    Promise.resolve(dispatch(actions.setOnboardingComplete(true)))
+  ])
+    // using DEPLOYMENTS_PAST_COMPLETED to ensure we get the intended onboarding state set after
+    // _advancing_ the onboarding progress
+    .then(() => dispatch(advanceOnboarding(onboardingStepNames.DEPLOYMENTS_PAST_COMPLETED_FAILURE)))
+);
+
+export const advanceOnboarding = createAsyncThunk(`${sliceName}/advanceOnboarding`, (stepId, { dispatch, getState }) => {
+  const steps = onboardingSteps;
+  const progress = steps.findIndex(step => step === getState().onboarding.progress);
+  const stepIndex = steps.findIndex(step => step === stepId);
+  // if there is no progress set yet, the onboarding state deduction hasn't happened
+  // and the subsequent settings persistence would overwrite what we stored
+  if (progress > stepIndex || getState().onboarding.progress === null) {
+    return;
+  }
+  const madeProgress = steps[stepIndex + 1];
+  const state = { ...getCurrentOnboardingState(getState()), progress: madeProgress };
+  state.complete = stepIndex + 1 >= steps.findIndex(step => step === onboardingStepNames.DEPLOYMENTS_PAST_COMPLETED_FAILURE) ? true : state.complete;
+  return Promise.all([dispatch(actions.setOnboardingProgress(madeProgress)), dispatch(saveUserSettings({ onboarding: state }))]);
+});

package/organizationSlice/constants.ts

@@ -0,0 +1,82 @@
+// Copyright 2020 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 { Integration } from '@northern.tech/store/api/types/MenderTypes';
+import { EXTERNAL_PROVIDER, apiUrl, useradmApiUrl } from '@northern.tech/store/constants';
+
+export const auditLogsApiUrl = `${apiUrl.v1}/auditlogs`;
+export const tenantadmApiUrlv1 = `${apiUrl.v1}/tenantadm`;
+export const tenantadmApiUrlv2 = `${apiUrl.v2}/tenantadm`;
+export const ssoIdpApiUrlv1 = `${apiUrl.v1}/useradm/sso/idp/metadata`;
+
+export const XML_METADATA_FORMAT = 'xml';
+export const JSON_METADATA_FORMAT = 'json';
+
+export const getSamlStartUrl = id => `${window.location.origin}${useradmApiUrl}/auth/sso/${id}/login`;
+export const getOidcStartUrl = id => `${window.location.origin}${useradmApiUrl}/oidc/${id}/start`;
+
+export const SSO_TYPES = {
+  saml: {
+    id: 'saml',
+    type: 'saml',
+    title: 'SAML',
+    metadataFormat: XML_METADATA_FORMAT,
+    editorLanguage: XML_METADATA_FORMAT,
+    contentType: 'application/samlmetadata+xml',
+    getStartUrl: getSamlStartUrl,
+    configDetails: [
+      { key: 'entityID', label: 'Entity ID', getValue: id => `${window.location.origin}${useradmApiUrl}/sso/sp/metadata/${id}` },
+      { key: 'acs', label: 'ACS URL', getValue: id => `${window.location.origin}${useradmApiUrl}/auth/sso/${id}/acs` },
+      { key: 'startURL', label: 'Start URL', getValue: getSamlStartUrl }
+    ]
+  },
+  oidc: {
+    id: 'oidc',
+    type: 'oidc',
+    title: 'OpenID Connect',
+    metadataFormat: JSON_METADATA_FORMAT,
+    editorLanguage: JSON_METADATA_FORMAT,
+    contentType: 'application/json',
+    getStartUrl: getOidcStartUrl,
+    configDetails: [{ key: 'startURL', label: 'Start Url', getValue: getOidcStartUrl }]
+  }
+};
+
+export const AUDIT_LOGS_TYPES = [
+  { title: 'Artifact', queryParameter: 'object_type', value: 'artifact' },
+  { title: 'Deployment', queryParameter: 'object_deployment_name', value: 'deployment' },
+  { title: 'Device', queryParameter: 'object_id', value: 'device' },
+  { title: 'User', queryParameter: 'object_id', value: 'user' }
+];
+
+export interface Webhook extends Integration {
+  provider: Integration.provider.WEBHOOK;
+  scopes?: string[];
+}
+
+export const emptyWebhook: Webhook = {
+  description: '',
+  enabled: true,
+  credentials: {
+    type: EXTERNAL_PROVIDER.webhook.credentialsType,
+    [EXTERNAL_PROVIDER.webhook.credentialsType]: {
+      secret: '',
+      url: ''
+    }
+  }
+};
+export const TENANT_LIST_DEFAULT = {
+  page: 1,
+  perPage: 20
+};

package/organizationSlice/index.ts

@@ -0,0 +1,111 @@
+// 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.
+import { DEVICE_LIST_DEFAULTS, SORTING_OPTIONS, TENANT_LIST_DEFAULT } from '@northern.tech/store/constants';
+import { createSlice } from '@reduxjs/toolkit';
+
+export const sliceName = 'organization';
+
+export const initialState = {
+  card: {
+    last4: '',
+    expiration: { month: 1, year: 2020 },
+    brand: ''
+  },
+  intentId: null,
+  organization: {
+    tenantList: {
+      ...TENANT_LIST_DEFAULT,
+      total: 0,
+      tenants: [],
+      selectedTenant: null,
+      sort: {
+        direction: SORTING_OPTIONS.desc,
+        key: 'name'
+      }
+    }
+    // id, name, status, tenant_token, plan
+  },
+  auditlog: {
+    events: [],
+    selectionState: {
+      ...DEVICE_LIST_DEFAULTS,
+      detail: undefined,
+      endDate: undefined,
+      selectedIssue: undefined,
+      sort: { direction: SORTING_OPTIONS.desc },
+      startDate: undefined,
+      total: 0,
+      type: undefined,
+      user: undefined
+    }
+  },
+  externalDeviceIntegrations: [
+    // { <connection_string|x509|...>, id, provider }
+  ],
+  ssoConfigs: [],
+  webhooks: {
+    // [id]: { events: [] }
+    // for now:
+    events: [],
+    eventsTotal: 0
+  }
+};
+
+export const organizationSlice = createSlice({
+  name: sliceName,
+  initialState,
+  reducers: {
+    receiveAuditLogs: (state, action) => {
+      const { events, total } = action.payload;
+      state.auditlog.events = events;
+      state.auditlog.selectionState.total = total;
+    },
+    setAuditLogState: (state, action) => {
+      state.auditlog.selectionState = {
+        ...state.auditlog.selectionState,
+        ...action.payload
+      };
+    },
+    receiveCurrentCard: (state, action) => {
+      state.card = action.payload;
+    },
+    receiveSetupIntent: (state, action) => {
+      state.intentId = action.payload;
+    },
+    setOrganization: (state, action) => {
+      state.organization = {
+        ...state.organization,
+        ...action.payload,
+        tenantList: { ...state.organization.tenantList, ...action.payload.tenantList }
+      };
+    },
+    setTenantListState: (state, action) => {
+      state.organization.tenantList = action.payload;
+    },
+    receiveExternalDeviceIntegrations: (state, action) => {
+      state.externalDeviceIntegrations = action.payload;
+    },
+    receiveSsoConfigs: (state, action) => {
+      state.ssoConfigs = action.payload;
+    },
+    receiveWebhookEvents: (state, action) => {
+      const { value, total } = action.payload;
+      state.webhooks.events = value;
+      state.webhooks.eventsTotal = total;
+    }
+  }
+});
+
+export const actions = organizationSlice.actions;
+export default organizationSlice.reducer;

package/organizationSlice/reducer.test.ts

@@ -0,0 +1,78 @@
+// Copyright 2020 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 { SORTING_OPTIONS } from '@northern.tech/store/commonConstants';
+
+import reducer, { actions, initialState } from '.';
+import { defaultState } from '../../../../tests/mockData';
+
+describe('organization reducer', () => {
+  it('should return the initial state', async () => {
+    expect(reducer(undefined, {})).toEqual(initialState);
+  });
+
+  it('should handle RECEIVE_AUDIT_LOGS', async () => {
+    expect(
+      reducer(undefined, { type: actions.receiveAuditLogs, payload: { events: defaultState.organization.auditlog.events, total: 2 } }).auditlog.selectionState
+        .total
+    ).toEqual(2);
+    expect(
+      reducer(initialState, { type: actions.receiveAuditLogs, payload: { events: defaultState.organization.auditlog.events, total: 4 } }).auditlog
+        .selectionState.total
+    ).toEqual(4);
+  });
+  it('should handle SET_AUDITLOG_STATE', async () => {
+    const newState = { something: 'new' };
+    expect(reducer(undefined, { type: actions.setAuditLogState, payload: newState }).auditlog.selectionState.something).toEqual(newState.something);
+    expect(reducer(initialState, { type: actions.setAuditLogState, payload: newState }).auditlog.selectionState).toEqual({
+      ...defaultState.organization.auditlog.selectionState,
+      ...newState,
+      sort: { direction: SORTING_OPTIONS.desc },
+      total: 0
+    });
+  });
+  it('should handle RECEIVE_CURRENT_CARD', async () => {
+    expect(reducer(undefined, { type: actions.receiveCurrentCard, payload: defaultState.organization.card }).card).toEqual(defaultState.organization.card);
+    expect(reducer(initialState, { type: actions.receiveCurrentCard, payload: defaultState.organization.card }).card).toEqual(defaultState.organization.card);
+  });
+  it('should handle RECEIVE_SETUP_INTENT', async () => {
+    expect(reducer(undefined, { type: actions.receiveSetupIntent, payload: defaultState.organization.intentId }).intentId).toEqual(
+      defaultState.organization.intentId
+    );
+    expect(reducer(initialState, { type: actions.receiveSetupIntent, payload: 4 }).intentId).toEqual(4);
+  });
+  it('should handle SET_ORGANIZATION', async () => {
+    expect(reducer(undefined, { type: actions.setOrganization, payload: defaultState.organization.organization }).organization.plan).toEqual(
+      defaultState.organization.organization.plan
+    );
+    expect(reducer(initialState, { type: actions.setOrganization, payload: defaultState.organization.organization }).organization.name).toEqual(
+      defaultState.organization.organization.name
+    );
+  });
+  it('should handle RECEIVE_EXTERNAL_DEVICE_INTEGRATIONS', async () => {
+    expect(reducer(undefined, { type: actions.receiveExternalDeviceIntegrations, payload: [] }).externalDeviceIntegrations).toEqual([]);
+    expect(reducer(initialState, { type: actions.receiveExternalDeviceIntegrations, payload: [12, 23] }).externalDeviceIntegrations).toEqual([12, 23]);
+  });
+  it('should handle RECEIVE_WEBHOOK_EVENTS', async () => {
+    expect(reducer(undefined, { type: actions.receiveWebhookEvents, payload: { value: [] } }).webhooks.events).toEqual([]);
+    expect(reducer(initialState, { type: actions.receiveWebhookEvents, payload: { value: [12, 23], total: 5 } }).webhooks).toEqual({
+      events: [12, 23],
+      eventsTotal: 5
+    });
+  });
+  it('should handle RECEIVE_SSO_CONFIGS', async () => {
+    expect(reducer(undefined, { type: actions.receiveSsoConfigs, payload: [] }).ssoConfigs).toEqual([]);
+    expect(reducer(initialState, { type: actions.receiveSsoConfigs, payload: [12, 23] }).ssoConfigs).toEqual([12, 23]);
+  });
+});