refactor: isolate dismissDuplicateTransactionViolation from Onyx.connect data

src/libs/actions/Transaction.ts

@@ -51,13 +51,13 @@
 import {getPolicyTagsData} from './Policy/Tag';
 
 let recentWaypoints: RecentWaypoint[] = [];
 Onyx.connect({
     key: ONYXKEYS.NVP_RECENT_WAYPOINTS,
     callback: (val) => (recentWaypoints = val ?? []),
 });
 
 const allTransactions: Record<string, Transaction> = {};
 Onyx.connect({
     key: ONYXKEYS.COLLECTION.TRANSACTION,
     callback: (transaction, key) => {
         if (!key || !transaction) {
@@ -69,7 +69,7 @@
 });
 
 let allTransactionDrafts: OnyxCollection<Transaction> = {};
 Onyx.connect({
     key: ONYXKEYS.COLLECTION.TRANSACTION_DRAFT,
     waitForCollectionCallback: true,
     callback: (value) => {
@@ -78,7 +78,7 @@
 });
 
 let allReports: OnyxCollection<Report> = {};
 Onyx.connect({
     key: ONYXKEYS.COLLECTION.REPORT,
     waitForCollectionCallback: true,
     callback: (value) => {
@@ -90,7 +90,7 @@
 });
 
 const allTransactionViolation: OnyxCollection<TransactionViolation[]> = {};
 Onyx.connect({
     key: ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS,
     callback: (transactionViolation, key) => {
         if (!key || !transactionViolation) {
@@ -102,7 +102,7 @@
 });
 
 let allTransactionViolations: TransactionViolations = [];
 Onyx.connect({
     key: ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS,
     callback: (val) => (allTransactionViolations = val ?? []),
 });
@@ -389,19 +389,31 @@
     });
 }
 
+type DismissDuplicateTransactionViolationProps = {
+    transactionIDs: string[];
+    dismissedPersonalDetails: PersonalDetails;
+    expenseReport: OnyxEntry<Report>;
+    policy: OnyxEntry<Policy>;
+    isASAPSubmitBetaEnabled: boolean;
+    allTransactionsCollection: OnyxCollection<Transaction>;
+    allTransactionViolationsCollection: OnyxCollection<TransactionViolation[]>;
+};
+
 /**
  * Dismisses the duplicate transaction violation for the provided transactionIDs
  * and updates the transaction to include the dismissed violation in the comment.
  */
-function dismissDuplicateTransactionViolation(
-    transactionIDs: string[],
-    dismissedPersonalDetails: PersonalDetails,
-    expenseReport: OnyxEntry<Report>,
-    policy: OnyxEntry<Policy>,
-    isASAPSubmitBetaEnabled: boolean,
-) {
-    const currentTransactionViolations = transactionIDs.map((id) => ({transactionID: id, violations: allTransactionViolation?.[id] ?? []}));
-    const currentTransactions = transactionIDs.map((id) => allTransactions?.[id]);
+function dismissDuplicateTransactionViolation({
+    transactionIDs,
+    dismissedPersonalDetails,
+    expenseReport,
+    policy,
+    isASAPSubmitBetaEnabled,
+    allTransactionsCollection,
+    allTransactionViolationsCollection,
+}: DismissDuplicateTransactionViolationProps) {
+    const currentTransactionViolations = transactionIDs.map((id) => ({transactionID: id, violations: allTransactionViolationsCollection?.[id] ?? []}));
+    const currentTransactions = transactionIDs.map((id) => allTransactionsCollection?.[id]).filter((transaction): transaction is Transaction => transaction !== undefined);
     const transactionsReportActions = currentTransactions.map((transaction) => getIOUActionForReportID(transaction.reportID, transaction.transactionID));
     const optimisticDismissedViolationReportActions = transactionsReportActions.map(() => {
         return buildOptimisticDismissedViolationReportAction({reason: 'manual', violationName: CONST.VIOLATIONS.DUPLICATED_TRANSACTION});

src/pages/TransactionDuplicate/Review.tsx

@@ -25,7 +25,7 @@ import {isReportIDApproved, isSettled} from '@libs/ReportUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import type SCREENS from '@src/SCREENS';
-import type {Transaction} from '@src/types/onyx';
+import type {Transaction, TransactionViolations} from '@src/types/onyx';
 import DuplicateTransactionsList from './DuplicateTransactionsList';
 
 function TransactionDuplicateReview() {
@@ -47,11 +47,63 @@ function TransactionDuplicateReview() {
         [transactionViolations],
     );
     const transactionIDs = useMemo(() => (transactionID ? [transactionID, ...duplicateTransactionIDs] : duplicateTransactionIDs), [transactionID, duplicateTransactionIDs]);
+
+    const allTransactionsSelector = useCallback(
+        (allTransactions: OnyxCollection<Transaction>): OnyxCollection<Transaction> => {
+            if (!allTransactions) {
+                return {};
+            }
+
+            const filteredTransactions: OnyxCollection<Transaction> = {};
+            transactionIDs.forEach((id) => {
+                const key = `${ONYXKEYS.COLLECTION.TRANSACTION}${id}`;
+                if (allTransactions[key]) {
+                    filteredTransactions[key] = allTransactions[key];
+                }
+            });
+            return filteredTransactions;
+        },
+        [transactionIDs],
+    );
+
+    const [allTransactions] = useOnyx(
+        ONYXKEYS.COLLECTION.TRANSACTION,
+        {
+            selector: allTransactionsSelector,
+            canBeMissing: false,
+        },
+        [allTransactionsSelector],
+    );
+
+    const allTransactionViolationsSelector = useCallback(
+        (allViolations: OnyxCollection<TransactionViolations>): OnyxCollection<TransactionViolations> => {
+            if (!allViolations) {
+                return {};
+            }
+            const filteredViolations: OnyxCollection<TransactionViolations> = {};
+            transactionIDs.forEach((id) => {
+                const key = `${ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS}${id}`;
+                if (allViolations[key]) {
+                    filteredViolations[key] = allViolations[key];
+                }
+            });
+            return filteredViolations;
+        },
+        [transactionIDs],
+    );
+
+    const [allTransactionViolation] = useOnyx(
+        ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS,
+        {
+            selector: allTransactionViolationsSelector,
+            canBeMissing: false,
+        },
+        [allTransactionViolationsSelector],
+    );
+
     const transactionsSelector = useCallback(
-        (allTransactions: OnyxCollection<Transaction>) =>
-            transactionIDs
-                .map((id) => allTransactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${id}`])
-                .sort((a, b) => new Date(a?.created ?? '').getTime() - new Date(b?.created ?? '').getTime()),
+        (transactions: OnyxCollection<Transaction>) =>
+            transactionIDs.map((id) => transactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${id}`]).sort((a, b) => new Date(a?.created ?? '').getTime() - new Date(b?.created ?? '').getTime()),
         [transactionIDs],
     );
 
@@ -65,7 +117,15 @@ function TransactionDuplicateReview() {
     );
 
     const keepAll = () => {
-        dismissDuplicateTransactionViolation(transactionIDs, currentPersonalDetails, expenseReport, policy, isASAPSubmitBetaEnabled);
+        dismissDuplicateTransactionViolation({
+            transactionIDs,
+            dismissedPersonalDetails: currentPersonalDetails,
+            expenseReport,
+            policy,
+            isASAPSubmitBetaEnabled,
+            allTransactionsCollection: allTransactions,
+            allTransactionViolationsCollection: allTransactionViolation,
+        });
         Navigation.goBack();
     };