Add new HOC to get policy.connections data

src/libs/API/parameters/OpenPolicyAccountingPageParams.ts

@@ -0,0 +1,5 @@
+type OpenPolicyAccountingPageParams = {
+    policyID: string;
+};
+
+export default OpenPolicyAccountingPageParams;

src/libs/API/parameters/index.ts

@@ -198,3 +198,4 @@ export type {default as SetPolicyCustomTaxNameParams} from './SetPolicyCustomTax
 export type {default as SetPolicyForeignCurrencyDefaultParams} from './SetPolicyForeignCurrencyDefaultParams';
 export type {default as SetPolicyCurrencyDefaultParams} from './SetPolicyCurrencyDefaultParams';
 export type {default as RenamePolicyTaxParams} from './RenamePolicyTaxParams';
+export type {default as OpenPolicyAccountingPageParams} from './OpenPolicyAccountingPageParams';

src/libs/API/types.ts

@@ -426,6 +426,7 @@ const READ_COMMANDS = {
     OPEN_POLICY_WORKFLOWS_PAGE: 'OpenPolicyWorkflowsPage',
     OPEN_POLICY_DISTANCE_RATES_PAGE: 'OpenPolicyDistanceRatesPage',
     OPEN_POLICY_MORE_FEATURES_PAGE: 'OpenPolicyMoreFeaturesPage',
+    OPEN_POLICY_ACCOUNTING_PAGE: 'OpenPolicyAccountingPage',
 } as const;
 
 type ReadCommand = ValueOf<typeof READ_COMMANDS>;
@@ -466,6 +467,7 @@ type ReadCommandParameters = {
     [READ_COMMANDS.OPEN_POLICY_WORKFLOWS_PAGE]: Parameters.OpenPolicyWorkflowsPageParams;
     [READ_COMMANDS.OPEN_POLICY_DISTANCE_RATES_PAGE]: Parameters.OpenPolicyDistanceRatesPageParams;
     [READ_COMMANDS.OPEN_POLICY_MORE_FEATURES_PAGE]: Parameters.OpenPolicyMoreFeaturesPageParams;
+    [READ_COMMANDS.OPEN_POLICY_ACCOUNTING_PAGE]: Parameters.OpenPolicyAccountingPageParams;
 };
 
 const SIDE_EFFECT_REQUEST_COMMANDS = {

src/libs/actions/PolicyConnections.ts

@@ -0,0 +1,15 @@
+import * as API from '@libs/API';
+import type {OpenPolicyAccountingPageParams} from '@libs/API/parameters';
+import {READ_COMMANDS} from '@libs/API/types';
+
+function openPolicyAccountingPage(policyID: string) {
+    const parameters: OpenPolicyAccountingPageParams = {
+        policyID,
+    };
+
+    API.read(READ_COMMANDS.OPEN_POLICY_ACCOUNTING_PAGE, parameters);
+}
+
+// More action functions will be added later
+// eslint-disable-next-line import/prefer-default-export
+export {openPolicyAccountingPage};

src/pages/workspace/withPolicyConnections.tsx

@@ -0,0 +1,73 @@
+import {useEffect, useState} from 'react';
+import type {ComponentType} from 'react';
+import FullPageOfflineBlockingView from '@components/BlockingViews/FullPageOfflineBlockingView';
+import useNetwork from '@hooks/useNetwork';
+import {openPolicyAccountingPage} from '@libs/actions/PolicyConnections';
+import withPolicy from './withPolicy';
+import type {WithPolicyProps} from './withPolicy';
+
+type WithPolicyConnectionsProps = WithPolicyProps;
+
+/**
+ * Higher-order component that fetches the connections data and populates
+ * the corresponding field of the policy object if the field is empty. It then passes the policy object
+ * to the wrapped component.
+ *
+ * Use this HOC when you need the policy object with its connections field populated.
+ *
+ * Only the active policy gets the complete policy data upon app start that includes the connections data.
+ * For other policies, the connections data needs to be fetched when it's needed.
+ */
+function withPolicyConnections(WrappedComponent: ComponentType<WithPolicyConnectionsProps>) {
+    function WithPolicyConnections({policy, policyMembers, policyDraft, policyMembersDraft, route}: WithPolicyConnectionsProps) {
+        const {isOffline} = useNetwork();
+
+        // When the accounting feature is enabled, but the user hasn't connected to any accounting software,
+        // the connections data doesn't exist. We don't want to continually attempt to fetch non-existent data.
+        // This state helps us track whether a data fetch attempt has been made.
+        const [wasConnectionsDataFetched, setWasConnectionsDataFetched] = useState(false);
+
+        useEffect(() => {
+            // When the accounting feature is not enabled, or if the connections data already exists,
+            // there is no need to fetch the connections data.
+            if (wasConnectionsDataFetched || !policy?.areConnectionsEnabled || !!policy?.connections || !policy?.id) {
+                return;
+            }
+
+            openPolicyAccountingPage(policy.id);
+            setWasConnectionsDataFetched(true);
+        }, [policy, wasConnectionsDataFetched]);
+
+        if (!policy?.connections) {
+            if (isOffline) {
+                return (
+                    <FullPageOfflineBlockingView>
+                        <WrappedComponent
+                            policy={policy}
+                            policyMembers={policyMembers}
+                            policyDraft={policyDraft}
+                            policyMembersDraft={policyMembersDraft}
+                            route={route}
+                        />
+                    </FullPageOfflineBlockingView>
+                );
+            }
+
+            return null;
+        }
+
+        return (
+            <WrappedComponent
+                policy={policy}
+                policyMembers={policyMembers}
+                policyDraft={policyDraft}
+                policyMembersDraft={policyMembersDraft}
+                route={route}
+            />
+        );
+    }
+
+    return withPolicy(WithPolicyConnections);
+}
+
+export default withPolicyConnections;