Skip to content

[Due for payment 2026-03-12][$250] Chat - Message sent in offline is not shown in reports page #82033

Closed

Description

@lanitochka17

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!


Version Number: V9.3.16-4
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: N/A
Email or phone of affected tester (no customers): dreamnitethedragon@gmail.com
Issue reported by: Applause Internal Team
Bug source: Exploratory - Significant User Experience Deterioration
Device used: Redminote 10S Android 13
App Component: Money Requests

Action Performed:

  1. Launch app
  2. Go to reports - expense ( select from Type dropdown)
  3. Go offline
  4. Add an expense (selecting 1:1 user)
  5. Note expense added in offline is shown in reports page
  6. Go online
  7. Go to reports - chat ( select from Type dropdown)
  8. Go offline
  9. Send a message (selecting 1:1 user)
  10. Note message sent in offline is not shown in reports page

Expected Result:

Message sent in offline must be shown in reports page.

Actual Result:

Message sent in offline is not shown in reports page like expense.

Note:
Similarly task created in offline is also not shown in reports page.

Workaround:

Unknown

Platforms:

  • Android: App
  • Android: mWeb Chrome
  • iOS: App
  • iOS: mWeb Safari
  • iOS: mWeb Chrome
  • Windows: Chrome
  • MacOS: Chrome / Safari

Screenshots/Videos

Bug7073777_1770740260154.Screenrecorder-2026-02-10-21-34-49-996.mp4

View all open jobs on GitHub

Issue OwnerCurrent Issue Owner: @johncschuster
Upwork Automation - Do Not Edit
  • Upwork Job URL: https://www.upwork.com/jobs/~022021291443723323592
  • Upwork Job ID: 2021291443723323592
  • Last Price Increase: 2026-02-17

Activity

  1. added
    ExternalAdded to denote the issue can be worked on by a contributor
    on Feb 10, 2026
  2. added
    BugSomething is broken. Auto assigns a BugZero manager.
    on Feb 10, 2026
  3. added
    Help WantedApply this label when an issue is open to proposals by contributors
    on Feb 10, 2026
  4. melvin-bot commented on Feb 10, 2026

    @melvin-bot

    Triggered auto assignment to Contributor-plus team member for initial proposal review - @hungvu193 (External)

  5. melvin-bot commented on Feb 10, 2026

    @melvin-bot

    Triggered auto assignment to @johncschuster (Bug), see https://stackoverflow.com/c/expensify/questions/14418 for more details. Please add this bug to a GH project, as outlined in the SO.

  6. changed the title [-]Chat - Message sent in offline is not shown in reports page[/-] [+][$250] Chat - Message sent in offline is not shown in reports page[/+] on Feb 10, 2026
  7. melvin-bot commented on Feb 10, 2026

    @melvin-bot
  8. harjot96 commented on Feb 10, 2026

    @harjot96

    Proposal

    Please re-state the problem that we are trying to solve in this issue.
    When a user sends a message or creates a task while offline, the new item does not appear in the Reports (Search) page list. This occurs because the ONYXKEYS.COLLECTION.SNAPSHOT key, which drives the data for the Search page, is not being updated optimistically for these actions. The items only appear after the device goes online and the server responds.

    Solution

    Manually update the ONYXKEYS.COLLECTION.SNAPSHOT Onyx key with optimistic data when a user adds a comment or creates a task, similar to how it is currently handled for Expenses.

    1. For Messages (Chats):
      In src/libs/actions/Report/index.ts, inside the addActions function, we now retrieve the current search query. If the current search type is CHAT, we optimistically merge the new report and report actions into the current snapshot hash.

    2. For Tasks:
      In src/libs/actions/Task.ts, inside the createTaskAndNavigate function, we check if the current search type is CHAT or TASK. If so, we optimistically merge the new task report, the updated parent report, and the created report actions into the current snapshot hash.

    This ensures that offline actions are immediately reflected in the UI, providing a consistent "offline-first" experience across all report types.

    Changes

    1. src/libs/actions/Report/index.ts

    Updated addActions to include optimistic snapshot updates.

    // ... imports
    import {getCurrentSearchQueryJSON} from '@libs/SearchQueryUtils';
    
    // ... inside addActions function
        const currentSearchQueryJSON = getCurrentSearchQueryJSON();
        if (currentSearchQueryJSON?.type === CONST.SEARCH.DATA_TYPES.CHAT) {
            // @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
            optimisticData.push({
                onyxMethod: Onyx.METHOD.MERGE,
                key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${currentSearchQueryJSON.hash}`,
                value: {
                    data: {
                        [`${ONYXKEYS.COLLECTION.REPORT}${reportID}`]: optimisticReport,
                        [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`]: optimisticReportActions,
                    },
                },
            });
        }
    // ...

    2. src/libs/actions/Task.ts

    Updated createTaskAndNavigate to include optimistic snapshot updates.

    // ... imports
    import {getCurrentSearchQueryJSON} from '@libs/SearchQueryUtils';
    
    // ... inside createTaskAndNavigate function
        const currentSearchQueryJSON = getCurrentSearchQueryJSON();
        if (currentSearchQueryJSON && (currentSearchQueryJSON.type === CONST.SEARCH.DATA_TYPES.CHAT || currentSearchQueryJSON.type === CONST.SEARCH.DATA_TYPES.TASK)) {
            // @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
            optimisticData.push({
                onyxMethod: Onyx.METHOD.MERGE,
                key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${currentSearchQueryJSON.hash}`,
                value: {
                    data: {
                        [`${ONYXKEYS.COLLECTION.REPORT}${optimisticTaskReport.reportID}`]: {
                            ...optimisticTaskReport,
                            pendingFields: {
                                createChat: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                                reportName: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                                description: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                                managerID: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                            },
                        },
                        [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${optimisticTaskReport.reportID}`]: {[optimisticTaskCreatedAction.reportActionID]: optimisticTaskCreatedAction as OnyxTypes.ReportAction},
                        [`${ONYXKEYS.COLLECTION.REPORT}${parentReportID}`]: optimisticParentReport,
                        [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`]: {[optimisticAddCommentReport.reportAction.reportActionID]: optimisticAddCommentReport.reportAction as OnyxTypes.ReportAction},
                    },
                },
            });
        }
    // ...
  9. abbasifaizan70 commented on Feb 10, 2026

    @abbasifaizan70
    Contributor

    Proposal

    Please re-state the problem that we are trying to solve in this issue.

    The message sent while offline must be shown on the Reports page when viewing Reports → Chat.


    What is the root cause of that problem?

    Chat search results on the Reports page come only from the search API snapshot stored in Onyx. When the user is offline, the search either does not run or returns stale data, so the snapshot never contains the newly created chat or the message. The UI only renders what is in that snapshot, so offline-created chats never appear.

    RCA – Code that causes the issue:

    1. SearchContext returns only snapshot data for Chat type (no merge with local Onyx).

      currentSearchResults is built from the snapshot keyed by search hash. For non–to-do searches it returns the snapshot as-is. There is no merge of chat reports that exist in Onyx (e.g. created or updated offline) but are not in the snapshot.

    const [snapshotSearchResults] = useOnyx(`${ONYXKEYS.COLLECTION.SNAPSHOT}${searchContextData.currentSearchHash}`, {canBeMissing: true});
    const todoSearchResultsData = useTodos();
    const currentSearchKey = searchContextData.currentSearchKey;
    const currentSearchHash = searchContextData.currentSearchHash;
    const {accountID} = useCurrentUserPersonalDetails();
    const suggestedSearches = useMemo(() => getSuggestedSearches(accountID), [accountID]);
    const shouldUseLiveData = !!currentSearchKey && isTodoSearch(currentSearchHash, suggestedSearches);
    // If viewing a to-do search, use live data from useTodos, otherwise return the snapshot data
    // We do this so that we can show the counters for the to-do search results without visiting the specific to-do page, e.g. show `Approve [3]` while viewing the `Submit` to-do search.
    const currentSearchResults = useMemo((): SearchResults | undefined => {
    if (shouldUseLiveData) {
    const liveData = todoSearchResultsData[currentSearchKey as keyof typeof todoSearchResultsData];
    const searchInfo: SearchResultsInfo = {
    ...(snapshotSearchResults?.search ?? defaultSearchInfo),
    count: liveData.metadata.count,
    total: liveData.metadata.total,
    currency: liveData.metadata.currency,
    };
    const hasResults = Object.keys(liveData.data).length > 0;
    // For to-do searches, always return a valid SearchResults object (even with empty data)
    // This ensures we show the empty state instead of loading/blocking views
    return {
    search: {...searchInfo, isLoading: false, hasResults},
    data: liveData.data,
    };
    }
    return snapshotSearchResults ?? undefined;
    }, [shouldUseLiveData, currentSearchKey, todoSearchResultsData, snapshotSearchResults]);

    Code in RCA (issue):

    const [snapshotSearchResults] = useOnyx(`${ONYXKEYS.COLLECTION.SNAPSHOT}${searchContextData.currentSearchHash}`, {canBeMissing: true});
    const todoSearchResultsData = useTodos();
    // ... no useOnyx for REPORT or REPORT_ACTIONS
    
    const currentSearchResults = useMemo((): SearchResults | undefined => {
        if (shouldUseLiveData) {
            // ... todo path
        }
        return snapshotSearchResults ?? undefined;  // Chat type: only snapshot, no local merge
    }, [shouldUseLiveData, currentSearchKey, todoSearchResultsData, snapshotSearchResults]);

    So for Reports → Chat, currentSearchResults.data is only the snapshot. Any chat created or updated offline (and thus only in Onyx) is never included.

    1. Chat list is built only from the data passed in (snapshot).

      getReportActionsSections(data) iterates only over keys in data (report action entries, reports, etc.). If the offline chat’s report and report actions are not in data, they are never rendered.

      App/src/libs/SearchUIUtils.ts

      Lines 1935 to 1971 in 580c98f

      for (const key in data) {
      if (isReportActionEntry(key)) {
      const reportActions = Object.values(data[key]);
      n += reportActions.length;
      for (const reportAction of reportActions) {
      const from = reportAction.accountID ? (data.personalDetailsList?.[reportAction.accountID] ?? emptyPersonalDetails) : emptyPersonalDetails;
      const report = data[`${ONYXKEYS.COLLECTION.REPORT}${reportAction.reportID}`] ?? {};
      const policy = data[`${ONYXKEYS.COLLECTION.POLICY}${report.policyID}`] ?? {};
      const originalMessage = isMoneyRequestAction(reportAction) ? getOriginalMessage<typeof CONST.REPORT.ACTIONS.TYPE.IOU>(reportAction) : undefined;
      const isSendingMoney = isMoneyRequestAction(reportAction) && originalMessage?.type === CONST.IOU.REPORT_ACTION_TYPE.PAY && originalMessage?.IOUDetails;
      const isReportArchived = isArchivedReport(data[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${report.reportID}`]);
      const invoiceReceiverPolicy: OnyxTypes.Policy | undefined =
      report?.invoiceReceiver?.type === CONST.REPORT.INVOICE_RECEIVER_TYPE.BUSINESS ? data[`${ONYXKEYS.COLLECTION.POLICY}${report.invoiceReceiver.policyID}`] : undefined;
      if (
      !shouldReportActionBeVisible(reportAction, reportAction.reportActionID, canUserPerformWriteAction(report, isReportArchived)) ||
      isDeletedAction(reportAction) ||
      isResolvedActionableWhisper(reportAction) ||
      reportAction.actionName === CONST.REPORT.ACTIONS.TYPE.CLOSED ||
      isCreatedAction(reportAction) ||
      isWhisperActionTargetedToOthers(reportAction) ||
      (isMoneyRequestAction(reportAction) && !!report?.isWaitingOnBankAccount && originalMessage?.type === CONST.IOU.REPORT_ACTION_TYPE.PAY && !isSendingMoney)
      ) {
      continue;
      }
      reportActionItems.push({
      ...reportAction,
      from,
      // eslint-disable-next-line @typescript-eslint/no-deprecated
      reportName: getSearchReportName({report, policy, personalDetails: data.personalDetailsList, transactions, invoiceReceiverPolicy, reports, policies, isReportArchived}),
      formattedFrom: from?.displayName ?? from?.login ?? '',
      date: reportAction.created,
      keyForList: reportAction.reportActionID,
      } as ReportActionListItemType);
      }
      }

      Code in RCA (issue):

      for (const key in data) {
          if (isReportActionEntry(key)) {
              const reportActions = Object.values(data[key]);
              // ... only processes report actions that are already in `data`
              for (const reportAction of reportActions) {
                  const report = data[`${ONYXKEYS.COLLECTION.REPORT}${reportAction.reportID}`] ?? {};
                  // If report/actions for offline chat are not in `data`, they are never shown

      So the list is strictly “what’s in data”. With Chat type, data is the snapshot only; offline chats are missing from the list.

    Summary:
    Reports → Chat uses only API snapshot data. Offline-created chats live only in Onyx and are never merged into the data passed to the list. Expenses work because expense flows already merge/optimistic-update the snapshot or use live Onyx data in other code paths.


    What changes do you think we should make in order to solve the problem?

    When the Reports search type is Chat, merge into the search results any local chat reports from Onyx that are not already in the snapshot. That way, chats created or updated offline (e.g. 1:1 with a sent message) appear in Reports → Chat without waiting for the next successful API search.

    All changes are in one file: App/src/components/Search/SearchContext.tsx.


    Change 1 – Imports: add isChatReport and isPolicyExpenseChat

    import {isMoneyRequestReport} from '@libs/ReportUtils';
    import {getSuggestedSearches, isTodoSearch, isTransactionListItemType, isTransactionReportGroupListItemType} from '@libs/SearchUIUtils';

    Old code:

    import {isMoneyRequestReport} from '@libs/ReportUtils';

    New code:

    import {isChatReport, isMoneyRequestReport, isPolicyExpenseChat} from '@libs/ReportUtils';

    Change 2 – Subscribe to Onyx REPORT, REPORT_ACTIONS, and PERSONAL_DETAILS_LIST

    const [snapshotSearchResults] = useOnyx(`${ONYXKEYS.COLLECTION.SNAPSHOT}${searchContextData.currentSearchHash}`, {canBeMissing: true});
    const todoSearchResultsData = useTodos();

    New code:

        const [snapshotSearchResults] = useOnyx(`${ONYXKEYS.COLLECTION.SNAPSHOT}${searchContextData.currentSearchHash}`, {canBeMissing: true});
        const todoSearchResultsData = useTodos();
        const [allReports] = useOnyx(ONYXKEYS.COLLECTION.REPORT, {canBeMissing: true});
        const [allReportActions] = useOnyx(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {canBeMissing: true});
        const [personalDetailsList] = useOnyx(ONYXKEYS.PERSONAL_DETAILS_LIST, {canBeMissing: true});

    Change 3 – When type is Chat, merge local chat reports into snapshot data

    const currentSearchResults = useMemo((): SearchResults | undefined => {
    if (shouldUseLiveData) {
    const liveData = todoSearchResultsData[currentSearchKey as keyof typeof todoSearchResultsData];
    const searchInfo: SearchResultsInfo = {
    ...(snapshotSearchResults?.search ?? defaultSearchInfo),
    count: liveData.metadata.count,
    total: liveData.metadata.total,
    currency: liveData.metadata.currency,
    };
    const hasResults = Object.keys(liveData.data).length > 0;
    // For to-do searches, always return a valid SearchResults object (even with empty data)
    // This ensures we show the empty state instead of loading/blocking views
    return {
    search: {...searchInfo, isLoading: false, hasResults},
    data: liveData.data,
    };
    }
    return snapshotSearchResults ?? undefined;
    }, [shouldUseLiveData, currentSearchKey, todoSearchResultsData, snapshotSearchResults]);

    New code:

        // When viewing Chat search, merge in chat reports from Onyx that are not in the snapshot (e.g. messages sent offline) so they appear in the Reports page.
        const currentSearchResults = useMemo((): SearchResults | undefined => {
            if (shouldUseLiveData) {
                const liveData = todoSearchResultsData[currentSearchKey as keyof typeof todoSearchResultsData];
                const searchInfo: SearchResultsInfo = {
                    ...(snapshotSearchResults?.search ?? defaultSearchInfo),
                    count: liveData.metadata.count,
                    total: liveData.metadata.total,
                    currency: liveData.metadata.currency,
                };
                const hasResults = Object.keys(liveData.data).length > 0;
                return {
                    search: {...searchInfo, isLoading: false, hasResults},
                    data: liveData.data,
                };
            }
    
            const snapshot = snapshotSearchResults;
            if (!snapshot?.data || snapshot.search?.type !== CONST.SEARCH.DATA_TYPES.CHAT) {
                return snapshot ?? undefined;
            }
    
            // Merge in chat reports from Onyx that are not in the search snapshot (e.g. 1:1 chats created or messages sent while offline)
            const snapshotData = snapshot.data as Record<string, unknown>;
            const mergedData = {...snapshotData};
    
            const reportKey = (reportID: string) => `${ONYXKEYS.COLLECTION.REPORT}${reportID}`;
            const reportActionsKey = (reportID: string) => `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`;
    
            for (const report of Object.values(allReports ?? {})) {
                if (!report?.reportID || !isChatReport(report) || report.parentReportID || isPolicyExpenseChat(report)) {
                    continue;
                }
                const rKey = reportKey(report.reportID);
                if (mergedData[rKey] != null) {
                    continue;
                }
                const actions = allReportActions?.[reportActionsKey(report.reportID)];
                if (!actions || Object.keys(actions).length === 0) {
                    continue;
                }
                mergedData[rKey] = report;
                mergedData[reportActionsKey(report.reportID)] = actions;
            }
    
            // Ensure personalDetailsList is present for display (e.g. "from" in chat list items)
            if (personalDetailsList && !mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST]) {
                mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST] = personalDetailsList;
            } else if (personalDetailsList && mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST]) {
                mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST] = {...(mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST] as Record<string, unknown>), ...personalDetailsList};
            }
    
            return {...snapshot, data: mergedData};
        }, [
            shouldUseLiveData,
            currentSearchKey,
            todoSearchResultsData,
            snapshotSearchResults,
            allReports,
            allReportActions,
            personalDetailsList,
        ]);

    What alternative solutions did you explore? (Optional)

    • Re-run or adapt search when coming back online: Would require extra API calls and handling for “partial” offline results; merging from Onyx is simpler and keeps the list consistent as soon as the user views Reports → Chat.
    • Merge at getReportActionsSections / Search component level: Possible, but merging in SearchContext keeps a single source of truth for “current search results” and avoids passing allReports / allReportActions down into the Search UI layer.
  10. twinkle-react commented on Feb 11, 2026

    @twinkle-react

    Proposal

    Please re-state the problem that we are trying to solve in this issue.

    A chat message sent while offline does not appear in the Reports list when filtering by Chat. Expenses created offline appear correctly, but offline-sent chat messages do not show up in the list.

    What is the root cause of that problem?

    In this flow, addComment → addActions builds optimistic child report actions and calls getOptimisticDataForAncestors, but this helper in src/libs/ReportUtils.ts assumes that updating only REPORT_ACTIONS is enough. This assumption is wrong because the Reports list depends on report-level fields like lastVisibleActionCreated. Since the optimistic REPORT merge is missing, the report metadata is not updated, and the offline message is not surfaced.

    What changes do you think we should make in order to solve the problem?

    State the single invariant you’re enforcing
    When adding optimistic child actions, ancestor reports must receive atomic optimistic updates for both ancestor REPORT_ACTIONS and ancestor REPORT metadata so listing and sorting code sees the change immediately.

    Point to the earliest incorrect assumption
    getOptimisticDataForAncestors assumed that updating only ${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${ancestorReportID} is enough for listing UIs. This is the earliest incorrect assumption.

    Apply the smallest shared-layer fix
    Modify getOptimisticDataForAncestors in src/libs/ReportUtils.ts to return both:

    • an Onyx MERGE for ${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${ancestorReportID}, and
    • an Onyx MERGE for ${ONYXKEYS.COLLECTION.REPORT}${ancestorReportID} setting lastVisibleActionCreated.

    This keeps the fix in one shared helper used by all callers.

    Show the exact code delta and scope
    Files changed

    • src/libs/ReportUtils.ts

    Function / logic modified

    • getOptimisticDataForAncestors(ancestors: Ancestor[], lastVisibleActionCreated: string, type: string)

    Scope size

    • One file changed. One helper updated. Small additive change.

    Edited function (exact code excerpt):

    function getOptimisticDataForAncestors(ancestors: Ancestor[], lastVisibleActionCreated: string, type: string): Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS>> {
        let previousActionDeleted = false;
        // For each ancestor we need to update both:
        // 1) the ancestor's reportAction entry (child counts, etc)
        // 2) the ancestor's report metadata so list views that read report-level fields (eg. lastVisibleActionCreated)
        // return a flattened array of Onyx updates for both keys.
        return ancestors.flatMap(({report: ancestorReport, reportAction: ancestorReportAction}, index) => {
            const updatedReportAction = updateOptimisticParentReportAction(
                ancestorReportAction,
                lastVisibleActionCreated,
                type,
                previousActionDeleted ? index + 1 : undefined,
            );
            previousActionDeleted = isDeletedAction(ancestorReportAction) && updatedReportAction.childVisibleActionCount === 0;
    
            const reportActionUpdate: OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS> = {
                onyxMethod: Onyx.METHOD.MERGE,
                key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${ancestorReport.reportID}`,
                value: {
                    [ancestorReportAction.reportActionID]: updatedReportAction,
                },
            };
    
            const reportUpdate: OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT> = {
                onyxMethod: Onyx.METHOD.MERGE,
                key: `${ONYXKEYS.COLLECTION.REPORT}${ancestorReport.reportID}`,
                value: {
                    // Update the ancestor report's lastVisibleActionCreated so list screens which rely on report-level
                    // metadata will surface the optimistic change immediately while offline.
                    lastVisibleActionCreated: lastVisibleActionCreated,
                },
            };
    
            return [reportActionUpdate, reportUpdate];
        });
    }

    Note risk and ownership

    • Owner: Report and Actions shared utilities in src/libs/ReportUtils.ts.
    • Risk: Low. The change is additive and centralized. Revert is one file.
    • Teams to notify: Report and Actions, LHN and OptionsList owners.

    Implementation note
    No callers need changes. Callers already pass the output of getOptimisticDataForAncestors into optimisticData. API.prepareRequest applies this via Onyx.update, so adding the REPORT merge makes the change visible while offline.

    What alternative solutions did you explore? (Optional)

    • Central shared helper change.
    • Caller-side patches.
    • UI recomputation of REPORT_ACTIONS.
  11. hungvu193 commented on Feb 13, 2026

    @hungvu193
    Contributor

    Reviewing shortly

  12. 16 remaining items

  13. melvin-bot commented on Feb 19, 2026

    @melvin-bot

    📣 @Uzaifm127 You have been assigned to this job!
    Please apply to the Upwork job and leave a comment on the Github issue letting us know when we can expect a PR to be ready for review 🧑‍💻
    Once you apply to this job, your Upwork ID will be stored and you will be automatically hired for future jobs!
    Keep in mind: Code of Conduct | Contributing 📖

  14. Uzaifm127 commented on Feb 19, 2026

    @Uzaifm127
    Contributor

    I'll try to raise a PR within 48 hours.

  15. hungvu193 commented on Mar 11, 2026

    @hungvu193
    Contributor

    The automation is failed. This issue will be due for payment on 12 Mar

  16. changed the title [-][$250] Chat - Message sent in offline is not shown in reports page[/-] [+][Due for payment 2026-03-12][$250] Chat - Message sent in offline is not shown in reports page[/+] on Mar 11, 2026
  17. johncschuster commented on Mar 11, 2026

    @johncschuster
    Contributor

    Payment Summary

  18. johncschuster commented on Mar 11, 2026

    @johncschuster
    Contributor

    @hungvu193 does this one need regression test steps? If so, can you post them?

  19. hungvu193 commented on Mar 12, 2026

    @hungvu193
    Contributor

    Regression test:

    1. Open the app either in mobile or web.
    2. Go offline.
    3. Send a message to 1:1 chat.
    4. Go to Reports > Chats (or select Type: chat from the dropdown in Reports page).
    5. Verify that the message sent offline in 1:1 chat is visible in Reports > Chats.
    6. Go to the same 1:1 chat in which we sent the message.
    7. Create a task.
    8. Go to Reports.
    9. Select the Chats from Type dropdown.
    10. Verify that the created task is shown in Reports > Chats.
    11. Select the Task from Type dropdown.
    12. Verify that the created task is shown in Reports > Task.

    Do we 👍 or 👎 ?

  20. twisterdotcom commented on Mar 12, 2026

    @twisterdotcom
    Contributor

    @hungvu193 has submitted payment for this report on ND here.

    SO: https://stackoverflowteams.com/c/expensify/questions/7582

    Zapier Logs Run ID: 00040eee-1c97-a19c-60b0-3f6f716b40a4
  21. Uzaifm127 commented on Mar 12, 2026

    @Uzaifm127
    Contributor

    @johncschuster Accepted the offer and requested the payment on upwork.

  22. johncschuster commented on Mar 13, 2026

    @johncschuster
    Contributor

    Paid! All done here!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Labels

BugSomething is broken. Auto assigns a BugZero manager.ExternalAdded to denote the issue can be worked on by a contributorReviewingHas a PR in reviewWeeklyKSv2

Type

No type

Projects

Milestone

No milestone

Relationships

None yet

Development

No branches or pull requests

Issue actions