@frontegg/redux-store 7.0.0-alpha.1 → 7.0.0-alpha.10

package/mocks/helpers.d.ts

@@ -0,0 +1 @@
+export declare const mockActionsExpect: <T extends object>(actions: T, exclude: (keyof T)[]) => T;

package/mocks/helpers.js

@@ -0,0 +1,16 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+export const mockActionsExpect = (actions, exclude) => {
+  return Object.keys(actions).reduce((acc, key) => {
+    if (exclude.includes(key)) {
+      return _extends({}, acc, {
+        [key]: actions[key]
+      });
+    }
+    return _extends({}, acc, {
+      [key]: () => {
+        // eslint-disable-next-line no-console
+        console.debug(`Action ${String(key)} was called`);
+      }
+    });
+  }, {});
+};

package/mocks/index.d.ts

@@ -0,0 +1,68 @@
+import { FronteggState, RestApi, SharedActions } from '../interfaces';
+declare const buildMockActions: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    authActions: import("..").AuthActions;
+    authStateActions: import("..").AuthStateActions;
+    connectivityActions: {
+        setConnectivityState: (state: Partial<import("..").ConnectivityState>) => void;
+        initData: () => void;
+        resetConnectivityState: () => void;
+        loadSlackActions: () => Promise<void>;
+        loadSlackChannels: () => Promise<void>;
+        loadDataAction: (_payload?: import("..").TPlatform[] | undefined) => Promise<void>;
+        loadConnectivityChannels: (_payload?: import("..").TPlatform[] | undefined) => Promise<void>;
+        postDataAction: (payload: import("../interfaces").WithCallback<import("..").TPostData, boolean>) => Promise<void>;
+        postChannelData: (payload: import("../interfaces").WithCallback<import("..").TPostData, boolean>) => Promise<void>;
+        postCodeAction: (payload: string) => Promise<void>;
+        postSlackCode: (payload: string) => Promise<void>;
+        loadScope: () => Promise<void>;
+        loadSlackPermissions: () => Promise<void>;
+        deleteWebhookConfigAction: (payload: import("../interfaces").WithCallback<{
+            webhookId: string;
+        }, boolean>) => Promise<void>;
+        deleteWebhookConfig: (payload: import("../interfaces").WithCallback<{
+            webhookId: string;
+        }, boolean>) => Promise<void>;
+        postWebhookTestAction: (payload: import("@frontegg/rest-api").IWebhookTest) => Promise<void>;
+        postWebhookTest: (payload: import("@frontegg/rest-api").IWebhookTest) => Promise<void>;
+        postWebhookRetryAction: (payload: string) => Promise<void>;
+        postWebhookRetry: (payload: string) => Promise<void>;
+        loadWebhookLogsAction: (payload: {
+            id: string;
+            offset: number;
+            limit: number;
+        }) => Promise<void>;
+        loadWebhookLogs: (payload: {
+            id: string;
+            offset: number;
+            limit: number;
+        }) => Promise<void>;
+        cleanWebhookTestData: () => void;
+        cleanWebhookLogsData: () => Promise<void>;
+        cleanWebhookTestMessage: (state: import("..").ConnectivityState) => Promise<void>;
+        cleanError: () => Promise<void>;
+        cleanSlackData: () => Promise<void>;
+    };
+    subscriptionsActions: import("..").SubscriptionsActions;
+    subscriptionsStateActions: import("..").SubscriptionsStateActions;
+    vendorActions: {
+        setVendorState: (state: Partial<import("..").VendorState>) => void;
+        resetVendorState: () => void;
+        loadVendorPublicInfo: () => Promise<void>;
+        loadVendorPublicConfiguration: () => Promise<void>;
+    };
+    auditsActions: {
+        setAuditsMetadataState: (state: Partial<import("..").AuditsMetadataState>) => void;
+        resetAuditsMetadataState: () => void;
+        loadAuditsMetadata: () => Promise<void>;
+        setAuditLogsState: (state: Partial<import("..").AuditLogsState>) => void;
+        resetAuditLogsState: () => void;
+        exportAuditsCsv: () => Promise<void>;
+        loadAuditLogs: (payload: import("../interfaces").WithSilentLoad<import("../interfaces").WithCallback<{
+            pageOffset: number;
+            pageSize?: number | undefined;
+            filter?: import("@frontegg/rest-api").QueryFilter[] | undefined;
+            sort?: import("@frontegg/rest-api").QuerySort[] | undefined;
+        }, boolean>>) => Promise<void>;
+    };
+};
+export default buildMockActions;

package/mocks/index.js

@@ -0,0 +1,25 @@
+import { buildAuthActions } from './auth-mocks';
+import { buildAuditsActions } from './audits-mocks';
+import { buildConnectivityActions } from './connectivity-mocks';
+import { buildSubscriptionsActions } from './subscriptions-mocks';
+import { buildVendorActions } from './vendor-mocks';
+const buildMockActions = (store, api, actions) => {
+  const {
+    authActions,
+    authStateActions
+  } = buildAuthActions(store, api, actions);
+  const connectivityActions = buildConnectivityActions(store, api, actions);
+  const [subscriptionsActions, subscriptionsStateActions] = buildSubscriptionsActions(store, api, actions);
+  const vendorActions = buildVendorActions(store, api, actions);
+  const auditsActions = buildAuditsActions(store, api, actions);
+  return {
+    authActions,
+    authStateActions,
+    connectivityActions,
+    subscriptionsActions,
+    subscriptionsStateActions,
+    vendorActions,
+    auditsActions
+  };
+};
+export default buildMockActions;

package/mocks/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/mocks/index.js",
+  "types": "./index.d.ts"
+}

package/mocks/subscriptions-mocks/billingActions-mocks/index.d.ts

@@ -0,0 +1,4 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+import { BillingActions, BillingStateActions } from '../../../subscriptions';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => [BillingActions, BillingStateActions];
+export default _default;

package/mocks/subscriptions-mocks/billingActions-mocks/index.js

@@ -0,0 +1,17 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import buildInformationActions from './informationActions.mocks';
+import buildPaymentMethodActions from './paymentMethodActions.mocks';
+import buildInvoicesActions from './invoicesActions.mocks';
+import buildSubscriptionActions from './subscriptionActions.mocks';
+export default ((store, api, actions) => {
+  const informationActions = buildInformationActions(store, api, actions);
+  const paymentMethodActions = buildPaymentMethodActions(store, api, actions);
+  const invoicesActions = buildInvoicesActions(store, api, actions);
+  const subscriptionActions = buildSubscriptionActions(store, api, actions);
+  return [_extends({}, informationActions, paymentMethodActions, invoicesActions, subscriptionActions), {
+    information: informationActions,
+    invoices: invoicesActions,
+    paymentMethod: paymentMethodActions,
+    subscription: subscriptionActions
+  }];
+});

package/mocks/subscriptions-mocks/billingActions-mocks/informationActions.mocks.d.ts

@@ -0,0 +1,8 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setBillingInformationState: (state: Partial<import("../../..").BillingInformationState>) => void;
+    resetBillingInformationState: () => void;
+    loadSummaries: (tenantId: string, forceActive?: boolean | undefined) => Promise<void>;
+    loadBillingInformation: (forceActive?: boolean | undefined) => Promise<void>;
+};
+export default _default;

package/mocks/subscriptions-mocks/billingActions-mocks/informationActions.mocks.js

@@ -0,0 +1,36 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { mockActionsExpect } from '../../helpers';
+import { buildInformationActions } from '../../../subscriptions/Billing/Information';
+import { planResponseMock, subscriptionResponseMock } from '../dummy';
+import { ProviderType } from '@frontegg/rest-api';
+import { delay } from '../../../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildInformationActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setBillingInformationState', 'resetBillingInformationState']);
+  mockedActions.loadBillingInformation = async () => {
+    var _planResponseMock$0$p, _planResponseMock$0$p2;
+    mockedActions.setBillingInformationState({
+      loading: true
+    });
+    await delay(500);
+    mockedActions.setBillingInformationState({
+      loading: false,
+      fetching: false,
+      summary: {
+        subscriptionId: subscriptionResponseMock.id,
+        paymentMethodId: 'mockPaymentMethodId',
+        tenantConfigurationId: 'mockTenantConfigurationId',
+        providerType: ProviderType.Stripe,
+        externallyManaged: false,
+        currentPlanId: planResponseMock[0].id,
+        defaultPlanId: planResponseMock[0].id
+      },
+      plan: _extends({}, planResponseMock[0], {
+        price: (_planResponseMock$0$p = planResponseMock[0].price) == null ? void 0 : _planResponseMock$0$p.amount,
+        currency: (_planResponseMock$0$p2 = planResponseMock[0].price) == null ? void 0 : _planResponseMock$0$p2.currency,
+        recurringInterval: 'month'
+      })
+    });
+  };
+  return mockedActions;
+});

package/mocks/subscriptions-mocks/billingActions-mocks/invoicesActions.mocks.d.ts

@@ -0,0 +1,10 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setBillingInvoiceState: (state: Partial<import("../../..").InvoicesState>) => void;
+    resetBillingInvoiceState: () => void;
+    loadInvoices: () => Promise<void>;
+    loadBillingInvoices: () => Promise<void>;
+    downloadInvoice: (payload: import("../../..").DownloadInvoiceActionPayload) => Promise<void>;
+    downloadBillingInvoice: (payload: import("../../..").DownloadInvoiceActionPayload) => Promise<void>;
+};
+export default _default;

package/mocks/subscriptions-mocks/billingActions-mocks/invoicesActions.mocks.js

@@ -0,0 +1,27 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { mockActionsExpect } from '../../helpers';
+import { invoicesMock } from '../dummy';
+import { delay } from '../../../helpers';
+import { buildInvoicesActions } from '../../../subscriptions/Billing/Invoices';
+export default ((store, api, actions) => {
+  const originalActions = buildInvoicesActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setBillingInvoiceState', 'resetBillingInvoiceState']);
+  mockedActions.loadBillingInvoices = async () => {
+    mockedActions.setBillingInvoiceState({
+      loading: true
+    });
+    await delay(500);
+    const selectPlanTitle = 'Premium';
+    mockedActions.setBillingInvoiceState({
+      loading: false,
+      fetching: false,
+      invoices: invoicesMock.map(invoice => _extends({}, invoice, {
+        selectedPlan: selectPlanTitle,
+        paymentDate: new Date(Date.parse(invoice.paymentDate)),
+        totalAmount: +((invoice.totalAmount || 0) / 100).toFixed(2)
+      }))
+    });
+  };
+  mockedActions.loadInvoices = mockedActions.loadBillingInvoices;
+  return mockedActions;
+});

package/mocks/subscriptions-mocks/billingActions-mocks/paymentMethodActions.mocks.d.ts

@@ -0,0 +1,11 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setBillingPaymentMethodState: (state: Partial<{}>) => void;
+    resetBillingPaymentMethodState: () => void;
+    loadPaymentMethod: () => Promise<void>;
+    submitPaymentMethod: () => Promise<void>;
+    submitPaymentMethodError: (error: string) => Promise<void>;
+    submitPaymentMethodSuccess: () => Promise<void>;
+    updatePaymentMethodBillingDetails: (payload: import("../../../interfaces").WithCallback<import("../../../interfaces").WithId<import("@frontegg/rest-api").ISubscriptionUpdatePaymentMethodBillingDetails>, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/subscriptions-mocks/billingActions-mocks/paymentMethodActions.mocks.js

@@ -0,0 +1,20 @@
+import { mockActionsExpect } from '../../helpers';
+import { paymentMethodsMock } from '../dummy';
+import { delay } from '../../../helpers';
+import { buildPaymentMethodActions } from '../../../subscriptions/Billing/PaymentMethod';
+export default ((store, api, actions) => {
+  const originalActions = buildPaymentMethodActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setBillingPaymentMethodState', 'resetBillingPaymentMethodState']);
+  mockedActions.loadPaymentMethod = async () => {
+    mockedActions.setBillingPaymentMethodState({
+      loading: true
+    });
+    await delay(500);
+    mockedActions.setBillingPaymentMethodState({
+      paymentMethod: paymentMethodsMock[0],
+      loading: false,
+      fetching: false
+    });
+  };
+  return mockedActions;
+});

package/mocks/subscriptions-mocks/billingActions-mocks/subscriptionActions.mocks.d.ts

@@ -0,0 +1,14 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setBillingSubscriptionState: (state: Partial<{}>) => void;
+    resetBillingSubscriptionState: () => void;
+    setCancellationLoading: (loading: boolean) => void;
+    setCancellationError: (error: string | null) => void;
+    setRenewalLoading: (loading: boolean) => void;
+    setRenewalError: (error: string | null) => void;
+    loadSubscription: () => Promise<void>;
+    loadSubscriptionTenant: () => Promise<void>;
+    cancelSubscription: () => Promise<void>;
+    renewSubscription: () => Promise<void>;
+};
+export default _default;

package/mocks/subscriptions-mocks/billingActions-mocks/subscriptionActions.mocks.js

@@ -0,0 +1,21 @@
+import { mockActionsExpect } from '../../helpers';
+import { subscriptionResponseMock } from '../dummy';
+import { delay } from '../../../helpers';
+import { buildSubscriptionActions } from '../../../subscriptions/Billing/Subscription';
+export default ((store, api, actions) => {
+  const originalActions = buildSubscriptionActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setBillingSubscriptionState', 'resetBillingSubscriptionState', 'setCancellationLoading', 'setCancellationError', 'setRenewalLoading', 'setRenewalError']);
+  mockedActions.loadSubscription = async () => {
+    mockedActions.setBillingSubscriptionState({
+      loading: true
+    });
+    await delay(500);
+    mockedActions.setBillingSubscriptionState({
+      subscription: subscriptionResponseMock,
+      fetching: false,
+      loading: false,
+      error: null
+    });
+  };
+  return mockedActions;
+});

package/mocks/subscriptions-mocks/checkoutActions.mocks.d.ts

@@ -0,0 +1,11 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setCheckoutState: (state: Partial<import("../..").CheckoutState>) => void;
+    resetCheckoutState: () => void;
+    loadCheckout: () => void;
+    resetCheckout: () => void;
+    submitCheckout: () => void;
+    confirmCheckout: (payload: import("../..").ConfirmCheckoutActionPayload) => Promise<void>;
+    errorCheckout: (payload: string) => void;
+};
+export default _default;

package/mocks/subscriptions-mocks/checkoutActions.mocks.js

@@ -0,0 +1,7 @@
+import { mockActionsExpect } from '../helpers';
+import { buildCheckoutActions } from '../../subscriptions/Checkout';
+export default ((store, api, actions) => {
+  const originalActions = buildCheckoutActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setCheckoutState', 'resetCheckoutState', 'errorCheckout', 'resetCheckout']);
+  return mockedActions;
+});

package/mocks/subscriptions-mocks/configActions.mocks.d.ts

@@ -0,0 +1,7 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setPaymentConfigState: (state: Partial<import("../..").PaymentProviderConfigState>) => void;
+    resetPaymentConfigState: () => void;
+    loadPaymentConfiguration: () => Promise<void>;
+};
+export default _default;

package/mocks/subscriptions-mocks/configActions.mocks.js

@@ -0,0 +1,23 @@
+import { mockActionsExpect } from '../helpers';
+import { delay } from '../../helpers';
+import { buildConfigActions } from '../../subscriptions/Config';
+import { PaymentProvider } from '../../subscriptions/interfaces';
+export default ((store, api, actions) => {
+  const originalActions = buildConfigActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setPaymentConfigState', 'resetPaymentConfigState']);
+  mockedActions.loadPaymentConfiguration = async () => {
+    mockedActions.setPaymentConfigState({
+      loading: true
+    });
+    await delay(500);
+    mockedActions.setPaymentConfigState({
+      loading: false,
+      fetching: false,
+      config: {
+        paymentProvider: PaymentProvider.STRIPE,
+        apiKey: ''
+      }
+    });
+  };
+  return mockedActions;
+});

package/mocks/subscriptions-mocks/index.d.ts

@@ -0,0 +1,3 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { SubscriptionsActions, SubscriptionsStateActions } from '../../subscriptions';
+export declare const buildSubscriptionsActions: (store: FronteggState, api: RestApi, actions: SharedActions) => [SubscriptionsActions, SubscriptionsStateActions];

package/mocks/subscriptions-mocks/index.js

@@ -0,0 +1,23 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import buildConfigActions from './configActions.mocks';
+import buildBillingActions from './billingActions-mocks';
+import buildPlansActions from './plansActions.mocks';
+import buildCheckoutActions from './checkoutActions.mocks';
+import buildStripeActions from './stripeActions.mocks';
+import buildVendorPublicConfigActions from './vendorPublicConfigActions.mocks';
+export const buildSubscriptionsActions = (store, api, actions) => {
+  const configActions = buildConfigActions(store, api, actions);
+  const [billingActions, billingStateActions] = buildBillingActions(store, api, actions);
+  const plansActions = buildPlansActions(store, api, actions);
+  const checkoutActions = buildCheckoutActions(store, api, actions);
+  const stripeActions = buildStripeActions(store, api, actions);
+  const vendorPublicConfigActions = buildVendorPublicConfigActions(store, api, actions);
+  return [_extends({}, configActions, billingActions, plansActions, checkoutActions, stripeActions, vendorPublicConfigActions), {
+    config: configActions,
+    billing: billingStateActions,
+    plans: plansActions,
+    checkout: checkoutActions,
+    stripe: stripeActions,
+    vendorPublicConfig: vendorPublicConfigActions
+  }];
+};

package/mocks/subscriptions-mocks/plansActions.mocks.d.ts

@@ -0,0 +1,7 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setPlansState: (state: Partial<import("../..").PlansState>) => void;
+    resetPlansState: () => void;
+    loadPlans: () => Promise<void>;
+};
+export default _default;

package/mocks/subscriptions-mocks/plansActions.mocks.js

@@ -0,0 +1,28 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { mockActionsExpect } from '../helpers';
+import { buildPlansActions } from '../../subscriptions/Plans';
+import { delay } from '../../helpers';
+import { planResponseMock } from './dummy';
+export default ((store, api, actions) => {
+  const originalActions = buildPlansActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setPlansState', 'resetPlansState']);
+  mockedActions.loadPlans = async () => {
+    mockedActions.setPlansState({
+      loading: true
+    });
+    await delay(500);
+    mockedActions.setPlansState({
+      fetching: false,
+      loading: false,
+      plans: planResponseMock.map(item => {
+        var _item$price, _item$price2;
+        return _extends({}, item, {
+          price: ((_item$price = item.price) == null ? void 0 : _item$price.amount) || 0,
+          currency: ((_item$price2 = item.price) == null ? void 0 : _item$price2.currency) || 'usd',
+          recurringInterval: 'month'
+        });
+      })
+    });
+  };
+  return mockedActions;
+});

package/mocks/subscriptions-mocks/stripeActions.mocks.d.ts

@@ -0,0 +1,5 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    createCardSetupIntentSecret: (payload: string | null) => Promise<void>;
+};
+export default _default;

package/mocks/subscriptions-mocks/stripeActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildStripeActions } from '../../subscriptions/Stripe';
+export default ((store, api, actions) => {
+  const originalActions = buildStripeActions(store, api, actions);
+  return mockActionsExpect(originalActions, []);
+});

package/mocks/subscriptions-mocks/vendorPublicConfigActions.mocks.d.ts

@@ -0,0 +1,9 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setVendorPublicConfigState: (state: Partial<import("../..").VendorPublicConfigurationState>) => void;
+    resetVendorPublicConfigState: () => void;
+    setVendorPublicConfigError: (error: string) => void;
+    setVendorPublicConfigLoading: (loading: boolean) => void;
+    loadVendorPublicConfiguration: () => Promise<void>;
+};
+export default _default;

package/mocks/subscriptions-mocks/vendorPublicConfigActions.mocks.js

@@ -0,0 +1,18 @@
+import { mockActionsExpect } from '../helpers';
+import { buildVendorPublicConfigActions } from '../../subscriptions/VendorPublicConfig';
+import { delay } from '../../helpers';
+import { vendorPublicConfigurationResponseMock } from './dummy';
+export default ((store, api, actions) => {
+  const originalActions = buildVendorPublicConfigActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setVendorPublicConfigState', 'resetVendorPublicConfigState', 'setVendorPublicConfigError', 'setVendorPublicConfigLoading']);
+  mockedActions.loadVendorPublicConfiguration = async () => {
+    mockedActions.setVendorPublicConfigLoading(true);
+    await delay();
+    mockedActions.setVendorPublicConfigState({
+      fetching: false,
+      loading: false,
+      vendorPublicConfig: vendorPublicConfigurationResponseMock
+    });
+  };
+  return mockedActions;
+});

package/mocks/vendor-mocks/index.d.ts

@@ -0,0 +1,7 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+export declare const buildVendorActions: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setVendorState: (state: Partial<import("../..").VendorState>) => void;
+    resetVendorState: () => void;
+    loadVendorPublicInfo: () => Promise<void>;
+    loadVendorPublicConfiguration: () => Promise<void>;
+};

package/mocks/vendor-mocks/index.js

@@ -0,0 +1,19 @@
+import { buildVendorActions as originalBuildVendorActions } from '../../vendor';
+import { mockActionsExpect } from '../helpers';
+import { delay } from '../../helpers';
+export const buildVendorActions = (store, api, actions) => {
+  const originalActions = originalBuildVendorActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setVendorState', 'resetVendorState']);
+  mockedActions.loadVendorPublicInfo = async () => {
+    try {
+      mockedActions.setVendorState({
+        whiteLabelMode: false
+      });
+      await delay();
+    } catch (e) {
+      console.error('failed to getVendorPublicInfo - ', e);
+    }
+  };
+  mockedActions.loadVendorPublicConfiguration = mockedActions.loadVendorPublicInfo;
+  return mockedActions;
+};

package/node/audits/AuditLogsState/actions.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _state = require("./state");
+var _helpers = require("../../helpers");
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setAuditLogsState = state => {
+    Object.assign(store.auditLogs.auditLogsState, state);
+  };
+  const resetAuditLogsState = () => {
+    store.auditLogs.auditLogsState = (0, _helpers.deepClone)(_state.initialState);
+  };
+  const exportAuditsCsv = async () => {
+    const state = store.auditLogs.auditLogsState;
+    const {
+      columns
+    } = store.auditLogs.auditsMetadataState;
+    try {
+      const filter = state.filter;
+      const sort = state.sort;
+      const sortParams = sort.reduce((p, n) => (0, _extends2.default)({}, p, {
+        sortBy: n.id,
+        sortDirection: n.desc ? 'desc' : 'asc'
+      }), {});
+      const filterParams = filter.reduce((p, n) => (0, _extends2.default)({}, p, {
+        [n.id]: n.value
+      }), {});
+      setAuditLogsState({
+        isDownloadingCsv: true
+      });
+      const outputFileName = `audits.csv`;
+      await api.audits.exportAudits((0, _extends2.default)({
+        endpoint: 'csv/v2',
+        headerProps: columns,
+        offset: 0,
+        outputFileName
+      }, sortParams, filterParams));
+    } catch (e) {
+      console.error('failed to export audits - ', e);
+    }
+    setAuditLogsState({
+      isDownloadingCsv: false
+    });
+  };
+  const loadAuditLogs = async payload => {
+    setAuditLogsState({
+      loading: !(payload != null && payload.silentLoading),
+      error: null
+    });
+    const state = store.auditLogs.auditLogsState;
+    const {
+      columns
+    } = store.auditLogs.auditsMetadataState;
+    try {
+      var _payload$pageSize, _payload$pageOffset, _payload$filter, _payload$sort, _payload$callback;
+      const pageSize = (_payload$pageSize = payload.pageSize) != null ? _payload$pageSize : state.pageSize;
+      const pageOffset = (_payload$pageOffset = payload.pageOffset) != null ? _payload$pageOffset : state.pageOffset;
+      const filter = (_payload$filter = payload.filter) != null ? _payload$filter : state.filter;
+      const sort = (_payload$sort = payload.sort) != null ? _payload$sort : state.sort;
+      setAuditLogsState({
+        pageSize,
+        pageOffset,
+        filter,
+        sort
+      });
+      const sortParams = sort.reduce((p, n) => (0, _extends2.default)({}, p, {
+        sortBy: n.id,
+        sortDirection: n.desc ? 'desc' : 'asc'
+      }), {});
+      const filterParams = filter.reduce((p, n) => (0, _extends2.default)({}, p, {
+        [n.id]: n.value
+      }), {});
+      if (!columns) {
+        await actions.loadAuditsMetadata();
+      }
+      const {
+        data,
+        total
+      } = await api.audits.getAudits((0, _extends2.default)({
+        offset: pageOffset,
+        count: pageSize
+      }, sortParams, filterParams));
+      setAuditLogsState({
+        loading: false,
+        logs: data != null ? data : [],
+        totalPages: +Math.ceil(total / pageSize)
+      });
+      payload == null ? void 0 : (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, true);
+    } catch (e) {
+      var _payload$callback2;
+      setAuditLogsState({
+        loading: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      payload == null ? void 0 : (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, null, e);
+    }
+  };
+  return {
+    setAuditLogsState,
+    resetAuditLogsState,
+    exportAuditsCsv,
+    loadAuditLogs
+  };
+};
+exports.default = _default;