Fix IOU avatar overlap when sharing manual and scanned expenses

src/components/ReportActionAvatars/useReportActionAvatars.ts

@@ -6,13 +6,13 @@ import useLocalize from '@hooks/useLocalize';
 import useOnyx from '@hooks/useOnyx';
 import usePolicy from '@hooks/usePolicy';
 import useReportIsArchived from '@hooks/useReportIsArchived';
+import getNonEmptyStringOnyxID from '@libs/getNonEmptyStringOnyxID';
 import {addSMSDomainIfPhoneNumber} from '@libs/PhoneNumber';
 import {
     getDelegateAccountIDFromReportAction,
     getHumanAgentAccountIDFromReportAction,
     getHumanAgentFirstName,
     getOriginalMessage,
-    getReportAction,
     getReportActionActorAccountID,
     isMoneyRequestAction,
 } from '@libs/ReportActionsUtils';
@@ -31,6 +31,7 @@ import {
 import {getDefaultAvatar} from '@libs/UserAvatarUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
+import {getReportActionByIDSelector} from '@src/selectors/ReportAction';
 import type {InvitedEmailsToAccountIDs, OnyxInputOrEntry, Policy, Report, ReportAction} from '@src/types/onyx';
 import type {Icon as IconType} from '@src/types/onyx/OnyxCommon';
 import useReportPreviewSenderID from './useReportPreviewSenderID';
@@ -77,15 +78,13 @@ function useReportActionAvatars({
     const chatReport = isReportAChatReport ? report : reportChatReport;
     const iouReport = isReportAChatReport ? undefined : report;
 
-    let action;
+    const derivedActionReportID = iouReport?.parentReportActionID ? (chatReport?.reportID ?? iouReport?.chatReportID) : reportChatReport?.reportID;
+    const derivedActionID = iouReport?.parentReportActionID ?? (!iouReport ? chatReport?.parentReportActionID : undefined);
+    const [derivedAction] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${getNonEmptyStringOnyxID(!passedAction ? derivedActionReportID : undefined)}`, {
+        selector: (actions) => getReportActionByIDSelector(actions, derivedActionID),
+    });
 
-    if (passedAction) {
-        action = passedAction;
-    } else if (iouReport?.parentReportActionID) {
-        action = getReportAction(chatReport?.reportID ?? iouReport?.chatReportID, iouReport?.parentReportActionID);
-    } else if (!!reportChatReport && !!chatReport?.parentReportActionID && !iouReport) {
-        action = getReportAction(reportChatReport?.reportID, chatReport.parentReportActionID);
-    }
+    const action = passedAction ?? derivedAction;
 
     const [actionChildReport] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${action?.childReportID}`);
 

src/components/ReportActionAvatars/useReportPreviewSenderID.ts

@@ -7,11 +7,12 @@ import {convertAttendeesToArray} from '@libs/AttendeeUtils';
 import getNonEmptyStringOnyxID from '@libs/getNonEmptyStringOnyxID';
 import {getAllNonDeletedTransactions} from '@libs/MoneyRequestReportUtils';
 import {getPersonalDetailByEmail} from '@libs/PersonalDetailsUtils';
-import {getOriginalMessage, isMoneyRequestAction, isSentMoneyReportAction} from '@libs/ReportActionsUtils';
+import {getIOUActionForTransactionID, getOriginalMessage, isDeletedParentAction, isMoneyRequestAction, isSentMoneyReportAction} from '@libs/ReportActionsUtils';
 import {isDM, isIOUReport} from '@libs/ReportUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
-import type {Policy, Report, ReportAction, ReportActions, Transaction} from '@src/types/onyx';
+import {hasOnceLoadedReportActionsSelector, isLoadingInitialReportActionsSelector} from '@src/selectors/ReportMetaData';
+import type {OriginalMessageIOU, Policy, Report, ReportAction, ReportActions, Transaction} from '@src/types/onyx';
 
 function getSplitAuthor(transaction: Transaction, splits?: Array<ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.IOU>>) {
     const {originalTransactionID, source} = transaction.comment ?? {};
@@ -39,6 +40,94 @@ const getSplitsSelector = (actions: OnyxEntry<ReportActions>): Array<ReportActio
         .filter((act) => getOriginalMessage(act)?.type === CONST.IOU.REPORT_ACTION_TYPE.SPLIT);
 };
 
+function getTransactionDirectionSign(transaction: Transaction): number | undefined {
+    const modifiedAmount = Number(transaction.modifiedAmount);
+
+    if (Number.isFinite(modifiedAmount) && modifiedAmount !== 0) {
+        return Math.sign(modifiedAmount);
+    }
+
+    if (transaction.amount !== 0) {
+        return Math.sign(transaction.amount);
+    }
+
+    return undefined;
+}
+
+function hasPendingScanStateAndUnknownDirection(transaction: Transaction): boolean {
+    if (transaction.receipt?.source === undefined) {
+        return false;
+    }
+
+    if (transaction.receipt?.state !== CONST.IOU.RECEIPT_STATE.SCAN_READY && transaction.receipt?.state !== CONST.IOU.RECEIPT_STATE.SCANNING) {
+        return false;
+    }
+
+    if (getTransactionDirectionSign(transaction) !== undefined) {
+        return false;
+    }
+
+    return true;
+}
+
+function getPendingScanActorAccountID(transaction: Transaction, action: OnyxEntry<ReportAction>, iouReport: OnyxEntry<Report>, chatReport: OnyxEntry<Report>): number | undefined {
+    if (!hasPendingScanStateAndUnknownDirection(transaction)) {
+        return undefined;
+    }
+
+    const chatLastActorAccountID = Number(chatReport?.lastActorAccountID);
+    const validPendingScanActorAccountIDs = new Set([action?.childOwnerAccountID, action?.childManagerAccountID, iouReport?.ownerAccountID, iouReport?.managerID].filter(Boolean));
+
+    if (
+        Number.isFinite(chatLastActorAccountID) &&
+        chatLastActorAccountID > 0 &&
+        chatLastActorAccountID !== CONST.ACCOUNT_ID.CONCIERGE &&
+        validPendingScanActorAccountIDs.has(chatLastActorAccountID)
+    ) {
+        return chatLastActorAccountID;
+    }
+
+    const previewLastActorAccountID = Number(action?.childLastActorAccountID);
+
+    if (!Number.isFinite(previewLastActorAccountID) || previewLastActorAccountID <= 0) {
+        return undefined;
+    }
+
+    return previewLastActorAccountID;
+}
+
+function getAccountIDFromTransactionDirection(transaction: Transaction, action: OnyxEntry<ReportAction>, iouReport: OnyxEntry<Report>): number | undefined {
+    const directionSign = getTransactionDirectionSign(transaction);
+
+    if (directionSign === undefined) {
+        return undefined;
+    }
+
+    const accountID = Number(directionSign > 0 ? (action?.childOwnerAccountID ?? iouReport?.ownerAccountID) : (action?.childManagerAccountID ?? iouReport?.managerID));
+
+    if (!Number.isFinite(accountID) || accountID <= 0) {
+        return undefined;
+    }
+
+    return accountID;
+}
+
+function isExplicitlyDeletedIOUAction(iouAction: ReportAction): boolean {
+    const originalMessage = getOriginalMessage(iouAction) as OriginalMessageIOU | undefined;
+
+    if (originalMessage?.deleted || isDeletedParentAction(iouAction) || iouAction.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE) {
+        return true;
+    }
+
+    const message = iouAction.message;
+
+    if (Array.isArray(message)) {
+        return message.some((fragment) => !!fragment?.deleted);
+    }
+
+    return !!message?.deleted;
+}
+
 type GetReportPreviewSenderIDParams = {
     iouReport: OnyxEntry<Report>;
     action: OnyxEntry<ReportAction>;
@@ -48,25 +137,107 @@ type GetReportPreviewSenderIDParams = {
     splits: Array<ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.IOU>> | undefined;
     policy: OnyxEntry<Policy>;
     currentUserAccountID: number;
+    hasFinishedInitialReportActionsLoad?: boolean;
 };
 
-function getReportPreviewSenderID({iouReport, action, chatReport, iouActions, transactions, splits, policy, currentUserAccountID}: GetReportPreviewSenderIDParams): number | undefined {
+function getReportPreviewSenderID({
+    iouReport,
+    action,
+    chatReport,
+    iouActions,
+    transactions,
+    splits,
+    policy,
+    currentUserAccountID,
+    hasFinishedInitialReportActionsLoad,
+}: GetReportPreviewSenderIDParams): number | undefined {
     const isOptimisticReportPreview = action?.isOptimisticAction && action?.actionName === CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW && isIOUReport(iouReport);
 
     if (isOptimisticReportPreview) {
         return currentUserAccountID;
     }
+    const loadedTransactionCount = transactions?.length ?? 0;
+    const childMoneyRequestCount = action?.childMoneyRequestCount ?? 0;
+    const activeMoneyRequestCount = iouReport?.transactionCount ?? childMoneyRequestCount;
+    const activeIOUActions = iouActions?.filter((iouAction) => !isExplicitlyDeletedIOUAction(iouAction)) ?? [];
+    const uniqueIOUActionActorMap = new Map<string, number>();
 
-    // 1. If all amounts have the same sign - either all amounts are positive or all amounts are negative.
-    // We have to do it this way because there can be a case when actions are not available
-    // See: https://github.com/Expensify/App/pull/64802#issuecomment-3008944401
+    for (const iouAction of activeIOUActions) {
+        const iouTransactionID = (getOriginalMessage(iouAction) as OriginalMessageIOU | undefined)?.IOUTransactionID;
 
-    const areAmountsSignsTheSame = new Set(transactions?.map((tr) => Math.sign(tr.amount))).size < 2;
+        if (!iouTransactionID || iouAction.actorAccountID === undefined) {
+            continue;
+        }
+
+        uniqueIOUActionActorMap.set(iouTransactionID, iouAction.actorAccountID);
+    }
 
-    if (!areAmountsSignsTheSame) {
+    const hasCompleteActionCoverage = activeMoneyRequestCount > 0 && uniqueIOUActionActorMap.size >= activeMoneyRequestCount;
+    const areAllActiveChildRequestsCreatedByOneActor = uniqueIOUActionActorMap.size > 0 && new Set(uniqueIOUActionActorMap.values()).size < 2;
+    const canInferFromIOUActionsDuringPartialHydration = loadedTransactionCount > 0 && hasCompleteActionCoverage && activeIOUActions.length > 0 && areAllActiveChildRequestsCreatedByOneActor;
+
+    // After refresh, the preview action can hydrate before all active child transactions.
+    // Avoid collapsing to one avatar unless the available IOU actions already prove the remaining
+    // active requests all belong to the same sender.
+    if (!hasFinishedInitialReportActionsLoad && activeMoneyRequestCount > loadedTransactionCount && !canInferFromIOUActionsDuringPartialHydration) {
         return undefined;
     }
 
+    const transactionActorAccountIDs = transactions?.map((transaction) => {
+        return getIOUActionForTransactionID(activeIOUActions, transaction.transactionID)?.actorAccountID ?? getPendingScanActorAccountID(transaction, action, iouReport, chatReport);
+    });
+    const transactionSigns = transactions?.map((transaction) => getTransactionDirectionSign(transaction)) ?? [];
+
+    const hasActorAccountIDForEachTransaction =
+        activeIOUActions.length > 0 && !!transactionActorAccountIDs && transactionActorAccountIDs.length > 0 && transactionActorAccountIDs.every((accountID) => accountID !== undefined);
+
+    // 1. Use actorAccountID when it is available for every transaction. Otherwise, fall back to known transaction direction only.
+    if (hasActorAccountIDForEachTransaction) {
+        const areAllTransactionsCreatedByOneActor = new Set(transactionActorAccountIDs).size < 2;
+
+        if (!areAllTransactionsCreatedByOneActor) {
+            return undefined;
+        }
+    } else {
+        const transactionsWithUnknownDirection = (transactions ?? []).filter((transaction, index) => transactionSigns.at(index) === undefined);
+        const hasUnknownDirection = transactionSigns.some((sign) => sign === undefined);
+        const unknownDirectionComesOnlyFromPendingScans = transactionsWithUnknownDirection.length > 0 && transactionsWithUnknownDirection.every(hasPendingScanStateAndUnknownDirection);
+        const hasOnlyUnknownDirections = transactionSigns.length > 0 && transactionSigns.every((sign) => sign === undefined);
+        const hasOnlyUnknownNonPendingScanDirections =
+            hasOnlyUnknownDirections && transactionsWithUnknownDirection.every((transaction) => !hasPendingScanStateAndUnknownDirection(transaction));
+
+        if (unknownDirectionComesOnlyFromPendingScans) {
+            const inferredActorAccountIDs = (transactions ?? [])
+                .map((transaction, index) => {
+                    return transactionActorAccountIDs?.at(index) ?? getAccountIDFromTransactionDirection(transaction, action, iouReport);
+                })
+                .filter((accountID): accountID is number => accountID !== undefined);
+
+            if (new Set(inferredActorAccountIDs).size > 1) {
+                return undefined;
+            }
+        }
+
+        if (hasUnknownDirection && !unknownDirectionComesOnlyFromPendingScans && !hasOnlyUnknownNonPendingScanDirections) {
+            return undefined;
+        }
+
+        const knownTransactionSigns = transactionSigns.filter((sign): sign is number => sign !== undefined);
+
+        if (knownTransactionSigns.length === 0 && !hasOnlyUnknownNonPendingScanDirections) {
+            return undefined;
+        }
+
+        // 1. If all amounts have the same sign - either all amounts are positive or all amounts are negative.
+        // We have to do it this way because there can be a case when actions are not available.
+        // See: https://github.com/Expensify/App/pull/64802#issuecomment-3008944401
+        const areAmountsSignsTheSame = hasOnlyUnknownNonPendingScanDirections || new Set(knownTransactionSigns).size < 2;
+
+        if (!areAmountsSignsTheSame) {
+            return undefined;
+        }
+    }
+
     // 2. If there is only one attendee - we check that by counting unique emails converted to account IDs in the attendees list.
     // This is a fallback added because: https://github.com/Expensify/App/pull/64802#issuecomment-3007906310
 
@@ -86,13 +257,13 @@ function getReportPreviewSenderID({iouReport, action, chatReport, iouActions, tr
     }
 
     // If the action is a 'Send Money' flow, it will only have one transaction, but the person who sent the money is the child manager account, not the child owner account.
-    const isSendMoneyFlowBasedOnActions = !!iouActions && iouActions.every(isSentMoneyReportAction);
+    const isSendMoneyFlowBasedOnActions = activeIOUActions.length > 0 && activeIOUActions.every(isSentMoneyReportAction);
     // This is used only if there are no IOU actions in the Onyx
     // eslint-disable-next-line rulesdir/no-negated-variables
     const isSendMoneyFlowBasedOnTransactions =
         !!action && action.childMoneyRequestCount === 0 && transactions?.length === 1 && (chatReport ? isDM(chatReport) : policy?.type === CONST.POLICY.TYPE.PERSONAL);
 
-    const isSendMoneyFlow = !!iouActions && iouActions?.length > 0 ? isSendMoneyFlowBasedOnActions : isSendMoneyFlowBasedOnTransactions;
+    const isSendMoneyFlow = activeIOUActions.length > 0 ? isSendMoneyFlowBasedOnActions : isSendMoneyFlowBasedOnTransactions;
 
     const singleAvatarAccountID = isSendMoneyFlow ? action?.childManagerAccountID : action?.childOwnerAccountID;
 
@@ -108,14 +279,33 @@ function useReportPreviewSenderID({iouReport, action, chatReport}: {action: Onyx
     const [iouActions] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${getNonEmptyStringOnyxID(shouldFetchData ? iouReport?.reportID : undefined)}`, {
         selector: getIOUActionsSelector,
     });
+    const [hasOnceLoadedReportActions] = useOnyx(`${ONYXKEYS.COLLECTION.RAM_ONLY_REPORT_LOADING_STATE}${getNonEmptyStringOnyxID(shouldFetchData ? action?.childReportID : undefined)}`, {
+        selector: hasOnceLoadedReportActionsSelector,
+    });
+    const [isLoadingInitialReportActions] = useOnyx(`${ONYXKEYS.COLLECTION.RAM_ONLY_REPORT_LOADING_STATE}${getNonEmptyStringOnyxID(shouldFetchData ? action?.childReportID : undefined)}`, {
+        selector: isLoadingInitialReportActionsSelector,
+    });
+    const hasFinishedInitialReportActionsLoad = hasOnceLoadedReportActions === true || isLoadingInitialReportActions === false;
 
     const {transactions: reportTransactions} = useTransactionsAndViolationsForReport(shouldFetchData ? action?.childReportID : undefined);
     const transactions = useMemo(() => {
         if (!shouldFetchData) {
             return undefined;
         }
-        return getAllNonDeletedTransactions(reportTransactions, iouActions ?? []);
-    }, [reportTransactions, iouActions, shouldFetchData]);
+        const activeMoneyRequestCount = iouReport?.transactionCount ?? action?.childMoneyRequestCount ?? 0;
+        const allReportTransactions = Object.values(reportTransactions ?? {}).filter((transaction): transaction is Transaction => !!transaction);
+        const nonDeletedTransactionsIncludingOrphans = getAllNonDeletedTransactions(reportTransactions, iouActions ?? [], false, true);
+        const filteredTransactions =
+            nonDeletedTransactionsIncludingOrphans.length < allReportTransactions.length
+                ? getAllNonDeletedTransactions(reportTransactions, iouActions ?? [])
+                : nonDeletedTransactionsIncludingOrphans;
+
+        if (filteredTransactions.length < allReportTransactions.length && filteredTransactions.length < activeMoneyRequestCount) {
+            return nonDeletedTransactionsIncludingOrphans;
+        }
+
+        return filteredTransactions;
+    }, [reportTransactions, iouActions, shouldFetchData, iouReport?.transactionCount, action?.childMoneyRequestCount]);
 
     const [splits] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${getNonEmptyStringOnyxID(shouldFetchData ? chatReport?.reportID : undefined)}`, {
         selector: getSplitsSelector,
@@ -124,7 +314,7 @@ function useReportPreviewSenderID({iouReport, action, chatReport}: {action: Onyx
     const [policy] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY}${getNonEmptyStringOnyxID(shouldFetchData ? iouReport?.policyID : undefined)}`);
     const {accountID: currentUserAccountID} = useCurrentUserPersonalDetails();
 
-    return getReportPreviewSenderID({iouReport, action, chatReport, iouActions, transactions, splits, policy, currentUserAccountID});
+    return getReportPreviewSenderID({iouReport, action, chatReport, iouActions, transactions, splits, policy, currentUserAccountID, hasFinishedInitialReportActionsLoad});
 }
 
 export default useReportPreviewSenderID;

src/libs/ReportUtils.ts

@@ -7696,6 +7696,7 @@ function updateReportPreview(
             },
         ],
         childLastMoneyRequestComment: comment || reportPreviewAction?.childLastMoneyRequestComment,
+        childLastActorAccountID: isPayRequest ? reportPreviewAction?.childLastActorAccountID : deprecatedCurrentUserAccountID,
         childMoneyRequestCount: (reportPreviewAction?.childMoneyRequestCount ?? 0) + (isPayRequest ? 0 : 1),
         childRecentReceiptTransactionIDs: hasReceipt
             ? {

tests/unit/ReportUtilsTest.ts

@@ -160,6 +160,7 @@ import {
     sortIconsByName,
     sortOutstandingReportsBySelected,
     temporary_getMoneyRequestOptions,
+    updateReportPreview,
 } from '@libs/ReportUtils';
 import {buildOptimisticTransaction} from '@libs/TransactionUtils';
 import CONST from '@src/CONST';
@@ -10766,6 +10767,33 @@ describe('ReportUtils', () => {
         });
     });
 
+    describe('updateReportPreview', () => {
+        it('refreshes childLastActorAccountID when a new expense request is added', () => {
+            const chatReport: Report = {
+                ...createRandomReport(100, undefined),
+                type: CONST.REPORT.TYPE.CHAT,
+            };
+
+            const iouReport: Report = {
+                ...createRandomReport(200, undefined),
+                parentReportID: '1',
+                type: CONST.REPORT.TYPE.IOU,
+                ownerAccountID: 1,
+                managerID: 2,
+            };
+
+            const reportPreviewAction = buildOptimisticReportPreview(chatReport, iouReport);
+            const updatedPreviewAction = updateReportPreview(iouReport, reportPreviewAction, false, '', {
+                transactionID: 'transaction-1',
+                amount: 0,
+                created: '2026-05-19 10:00:00',
+                receipt: {source: 'receipt.jpg'},
+            } as Transaction);
+
+            expect(updatedPreviewAction.childLastActorAccountID).toBe(currentUserAccountID);
+        });
+    });
+
     describe('compute (Formula.ts for optimistic report names)', () => {
         const mockPolicy: Policy = {
             id: 'test-policy-id',