[$250] Unable to Reject an Expense Report in ND

[m-natarajan]

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:
Reproducible in staging?: Needs Reproduction (Unable to reproduce)
Reproducible in production?: Needs Reproduction
If this was caught during regression testing, add the test name, ID and link from BrowserStack:
Email or phone of affected tester (no customers):
Logs: https://stackoverflow.com/c/expensify/questions/4856
Expensify/Expensify Issue URL:
Issue reported by: @abbagail
Slack conversation (hyperlinked to channel name): #Expensify Bugs

Action Performed:

1. Open report with out expense
2. Click More
3. Select Reject

Expected Result:

Reject a report that has no expenses on it.

Actual Result:

No reject option pops up. They have to switch to Classic to use the Reject Report button.

Workaround:

Unknown

Platforms:

Select the officially supported platforms where the issue was reproduced:

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

Screenshots/Videos

The video for the issue is in Slack thread

View all open jobs on GitHub

Issue Owner

Current Issue Owner: @ChavdaSachin

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022035132341938481902
• Upwork Job ID: 2035132341938481902
• Last Price Increase: 2026-03-20

[MelvinBot]

This has been labelled "Needs Reproduction". Follow the steps here: https://stackoverflowteams.com/c/expensify/questions/16989

[MelvinBot]

Proposal

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

When an approver opens an expense report with no expenses in New Dot and clicks "More" (three-dot menu), the "Reject" option does not appear. The user has to switch to Classic to reject the report. This also affects reports with 2+ expenses — the Reject option in the More menu only appears for reports with exactly 1 expense.

What is the root cause of that problem?

The Reject action's visibility is controlled by two independent layers, both of which block it for empty reports:

Layer 1 — Business logic gate (src/libs/ReportSecondaryActionUtils.ts:954): canRejectReportAction() (defined at src/libs/ReportUtils.ts:12908-12931) requires the report to be in processing state (stateNum === SUBMITTED && statusNum === SUBMITTED). An empty report is typically in OPEN state (stateNum=0, statusNum=0), so reject is never even added to the secondary actions list.

Layer 2 — UI-level filter (src/components/MoneyReportHeader.tsx:2157): Even if Layer 1 passes (e.g., a submitted report where all expenses were subsequently removed), the Reject menu item has:

shouldShow: transactions.length === 1

This means the Reject option is only shown for reports with exactly 1 transaction. For 0 transactions, this evaluates to false, and the action is filtered out at line 2192:

const applicableSecondaryActions = secondaryActions
    .map((action) => secondaryActionsImplementation[action])
    .filter((action) => action?.shouldShow !== false && action?.value !== primaryAction);

Deeper design issue: The reject functionality in New Dot is fundamentally per-transaction, not per-report. rejectMoneyRequestReason() (src/libs/ReportUtils.ts:5147) extracts a single transactionID from a reportAction and navigates to the reject reason page for that specific transaction. There is no report-level "reject entire report" action like Classic has.

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

This requires a product decision on the intended behavior for rejecting reports with 0 or 2+ expenses. Two approaches:

Option A — Add report-level reject (matches Classic behavior):

• Create a new report-level reject flow that changes the report's state back to OPEN/rejected without requiring a transactionID
• In ReportSecondaryActionUtils.ts, keep the canRejectReportAction check but remove the transaction-count dependency
• In MoneyReportHeader.tsx, change shouldShow: transactions.length === 1 to shouldShow: true (or remove it)
• When there are 0 expenses, skip the per-transaction reject reason page and instead directly reject/return the report
• When there is 1 expense, keep the current per-transaction flow
• When there are 2+ expenses, either reject all at once or use the existing selection mode flow

Option B — Minimal fix for the reported scenario:

• Add a new "Reject Report" action specifically for empty reports that sends the report back to the submitter without per-transaction flows
• Keep the existing per-transaction reject for reports with expenses

Either option likely requires backend support for a report-level reject API, since rejectMoneyRequest (src/libs/actions/IOU/index.ts) currently operates on individual transactions only.

What alternative solutions did you explore? (Optional)

• Simply removing the shouldShow: transactions.length === 1 check would expose the Reject button but the action would fail for reports with 0 expenses (no transactionID to pass to rejectMoneyRequestReason), and for reports with 2+ expenses it would only reject the first transaction's reportAction.
• Using the existing bulk selection mode (useSelectedTransactionsActions.ts:255-262) for multi-expense reports is already possible but doesn't help for empty reports since there are no transactions to select.

---

Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, @MelvinBot <your feedback> to refine this analysis, or explain why you are rejecting Melvin's proposal.

[melvin-bot]

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

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022035132341938481902

[husamdaifalla01-cmyk]

Proposal

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

When an approver opens a submitted expense report with zero expenses in New Dot and clicks the "More" menu, the "Reject" option does not appear. The same issue
affects reports with two or more expenses — Reject is also missing there. The user is forced to fall back to Classic. This is a regression: in Classic, Reject is
a report-level action independent of expense count.

---

What is the root cause of that problem?

There are three compounding layers. Understanding all three matters because fixing only Layer 1 without the others produces a visible-but-broken button.

---

Layer 1 — UI hard-gate: shouldShow: transactions.length === 1

File: src/components/MoneyReportHeader.tsx:2157

text: translate('common.reject'),
icon: expensifyIcons.ThumbsDown,
value: CONST.REPORT.SECONDARY_ACTIONS.REJECT,
sentryLabel: CONST.SENTRY_LABEL.MORE_MENU.REJECT,
onSelected: () => { ... },
shouldShow: transactions.length === 1, // ← blocks 0 and 2+ expense reports
},

The downstream filter at line 2190 removes any action where shouldShow is false:

const applicableSecondaryActions = secondaryActions
.map((action) => secondaryActionsImplementation[action])
.filter((action) => action?.shouldShow !== false && action?.value !== primaryAction);

Note: canRejectReportAction (src/libs/ReportSecondaryActionUtils.ts:954) correctly evaluates to true for an empty submitted report — it checks isProcessingReport
which only requires stateNum === SUBMITTED && statusNum === SUBMITTED, a condition an empty-but-submitted report satisfies. The permission gate passes. The bug
is entirely in this UI-level shouldShow condition.

---

Layer 2 — Silent no-op: if (requestParentReportAction) guard

File: src/components/MoneyReportHeader.tsx:2150

onSelected: () => {
if (isDelegateAccessRestricted) {
showDelegateNoAccessModal();
return;
}
if (dismissedRejectUseExplanation) {
if (requestParentReportAction) { // ← undefined for empty reports
rejectMoneyRequestReason(requestParentReportAction);
}
} else {
setRejectModalAction(CONST.REPORT.TRANSACTION_SECONDARY_ACTIONS.REJECT);
}
},

requestParentReportAction is resolved as:

const requestParentReportAction = useMemo(() => {
if (!reportActions || !transactionThreadReport?.parentReportActionID) {
return null;
}
return reportActions.find(
(action): action is OnyxTypes.ReportAction =>
action.reportActionID === transactionThreadReport.parentReportActionID,
);
}, [reportActions, transactionThreadReport?.parentReportActionID]);

An empty report has no transactions, so transactionThreadReport is null and requestParentReportAction is null. Even if Layer 1 were bypassed, the button would
render and do nothing on tap.

The educational modal path (setRejectModalAction) also has this problem: dismissRejectModalBasedOnAction (lines 1130–1151) eventually calls
rejectMoneyRequestReason(requestParentReportAction) on confirm — same null issue.

---

Layer 3 — Architectural mismatch: reject is per-transaction only

File: src/libs/ReportUtils.ts:5147 — rejectMoneyRequestReason

const rejectMoneyRequestReason = (reportAction: OnyxEntry): void => {
const originalMessage = getOriginalMessage(reportAction);
const transactionID = originalMessage?.IOUTransactionID; // ← requires a real transaction
if (!transactionID || !moneyRequestReportID) { return; }
Navigation.navigate(
ROUTES.REJECT_MONEY_REQUEST_REASON.getRoute(transactionID, moneyRequestReportID, activeRoute),
);
};

File: src/libs/API/parameters/RejectMoneyRequestParams.ts

type RejectMoneyRequestParams = {
transactionID: string; // required, non-optional
reportID: string;
comment: string;
rejectedActionReportActionID: string; // required
rejectedCommentReportActionID: string; // required
// ...
};

The entire pipeline — navigation, Onyx optimistic data, backend command — is built around a transactionID. Classic's report-level reject was never ported to New
Dot.

---

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

1. Remove the transaction-count guard — src/components/MoneyReportHeader.tsx

canRejectReportAction is the correct permission gate. shouldShow should not additionally restrict by expense count:

// Before
shouldShow: transactions.length === 1,

// After
shouldShow: true,

---

2. Branch onSelected for the zero-expense case — src/components/MoneyReportHeader.tsx

No type changes needed — reuse the existing rejectModalAction state and branch on transactions.length inside:

onSelected: () => {
if (isDelegateAccessRestricted) {
showDelegateNoAccessModal();
return;
}

  if (transactions.length === 0) {
      // Report-level reject: no transactionID available
      if (dismissedRejectUseExplanation) {
          Navigation.navigate(                                                                                                                                 
              ROUTES.REJECT_REPORT_REASON.getRoute(report.reportID, Navigation.getActiveRoute()),                                                              
          );                                                                                                                                                   
      } else {                                                                                                                                                 
          setRejectModalAction(CONST.REPORT.TRANSACTION_SECONDARY_ACTIONS.REJECT);                                                                             
      }                                                                                                                                                        
      return;                                                                                                                                                  
  }                                                                                                                                                            
                                                                                                                                                             
  // Existing per-transaction path (1+ expenses)                                                                                                               
  if (dismissedRejectUseExplanation) {
      if (requestParentReportAction) {                                                                                                                         
          rejectMoneyRequestReason(requestParentReportAction);                                                                                               
      }                                                                                                                                                        
  } else {                                                                                                                                                   
      setRejectModalAction(CONST.REPORT.TRANSACTION_SECONDARY_ACTIONS.REJECT);
  }                                                                                                                                                            

},

---

3. Update dismissRejectModalBasedOnAction for the zero-expense path — src/components/MoneyReportHeader.tsx:1130

This function fires when the user confirms the educational modal. It currently always calls rejectMoneyRequestReason(requestParentReportAction) for the REJECT
case. Add the same branch:

// Inside the REJECT case of dismissRejectModalBasedOnAction
if (transactions.length === 0) {
Navigation.navigate(
ROUTES.REJECT_REPORT_REASON.getRoute(report.reportID, Navigation.getActiveRoute()),
);
} else if (requestParentReportAction) {
rejectMoneyRequestReason(requestParentReportAction);
}

---

4. Add REJECT_REPORT_REASON route — src/ROUTES.ts

Following the existing pattern of REJECT_MONEY_REQUEST_REASON (line 3909):

REJECT_REPORT_REASON: {
route: 'reject/report/reason/:reportID',
getRoute: (reportID: string, backTo?: string) =>
reject/report/reason/${reportID}${backTo ? ?backTo=${backTo} : ''} as const,
},

---

5. Add RejectReportReasonPage — src/pages/iou/RejectReportReasonPage.tsx

Structurally mirrors the existing RejectReasonPage.tsx but accepts reportID only (no transactionID). On submit it calls rejectReportWithNoExpenses(reportID,
comment).

---

6. Add rejectReportWithNoExpenses — src/libs/actions/IOU/index.ts

function rejectReportWithNoExpenses(reportID: string, comment: string): void {
const rejectedActionID = rand64();
const commentActionID = rand64();

  const optimisticData: OnyxUpdate[] = [                                                                                                                       
      {                                                                                                                                                      
          onyxMethod: Onyx.METHOD.MERGE,                                                                                                                       
          key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,                                                                                                   
          value: {                                                                                                                                             
              statusNum: CONST.REPORT.STATUS_NUM.OPEN,
              stateNum: CONST.REPORT.STATE_NUM.OPEN,                                                                                                           
          },                                                                                                                                                   
      },                                                                                                                                                       
      {                                                                                                                                                        
          onyxMethod: Onyx.METHOD.MERGE,                                                                                                                     
          key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,                                                                                             
          value: {                                                                                                                                             
              [rejectedActionID]: {                                                                                                                            
                  actionName: CONST.REPORT.ACTIONS.TYPE.REJECTED,                                                                                              
                  actorAccountID: currentUserAccountID,                                                                                                        
                  message: [{type: 'COMMENT', html: comment, text: comment}],                                                                                  
                  pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,                                                                                      
                  reportActionID: rejectedActionID,                                                                                                            
                  created: DateUtils.getDBTime(),                                                                                                              
                  isOptimistic: true,                                                                                                                          
              },                                                                                                                                               
          },                                                                                                                                                 
      },                                                                                                                                                       
  ];                                                                                                                                                         
                                                                                                                                                               
  const failureData: OnyxUpdate[] = [                                                                                                                        
      {
          onyxMethod: Onyx.METHOD.MERGE,
          key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,                                                                                                     
          value: {                                                                                                                                             
              statusNum: CONST.REPORT.STATUS_NUM.SUBMITTED,                                                                                                    
              stateNum: CONST.REPORT.STATE_NUM.SUBMITTED,                                                                                                      
          },                                                                                                                                                   
      },                                                                                                                                                       
      {                                                                                                                                                        
          onyxMethod: Onyx.METHOD.MERGE,                                                                                                                     
          key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
          value: {[rejectedActionID]: null},                                                                                                                   
      },                                                                                                                                                       
  ];                                                                                                                                                           
                                                                                                                                                               
  const successData: OnyxUpdate[] = [                                                                                                                        
      {
          onyxMethod: Onyx.METHOD.MERGE,
          key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,                                                                                             
          value: {
              [rejectedActionID]: {pendingAction: null, isOptimistic: false},                                                                                  
          },                                                                                                                                                   
      },
  ];                                                                                                                                                           
                                                                                                                                                             
  API.write(
      WRITE_COMMANDS.REJECT_REPORT,
      {
          reportID,                                                                                                                                            
          comment,
          rejectedActionReportActionID: rejectedActionID,                                                                                                      
          rejectedCommentReportActionID: commentActionID,                                                                                                    
      },                                                                                                                                                       
      {optimisticData, successData, failureData},                                                                                                            
  );                                                                                                                                                           

}

---

7. Add REJECT_REPORT write command and params type

src/libs/API/WRITE_COMMANDS.ts:
REJECT_REPORT = 'RejectReport',

src/libs/API/parameters/RejectReportParams.ts (new file):
type RejectReportParams = {
reportID: string;
comment: string;
rejectedActionReportActionID: string;
rejectedCommentReportActionID: string;
};

export default RejectReportParams;

[gps949]

🚨 Edited by proposal-police: This proposal was edited at 2026-03-21 03:49:18 UTC.

Proposal

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

When an approver opens a submitted expense report with zero expenses in New Dot and clicks More, the Reject option does not appear. Users must switch to Classic to reject. This also affects reports with 2+ expenses.

What is the root cause of that problem?

In src/components/MoneyReportHeader.tsx, the REJECT secondary action has: shouldShow: transactions.length === 1. This hides Reject for 0 and 2+ expenses. The business logic (ReportUtils.canRejectReportAction()) correctly allows rejection but the UI gate blocks it.

Also, the onSelected handler derives requestParentReportAction from transactionThreadReport?.parentReportActionID which is null for empty reports - clicking Reject would silently no-op.

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

1. Fix visibility: change shouldShow: transactions.length === 1 to shouldShow: true in MoneyReportHeader.tsx (~line 2159)
2. Add report-level reject path in onSelected handler (~line 2150) for empty reports
3. Same branching in dismissRejectModalBasedOnAction (~line 1130)
4. For multi-transaction reports, iterate and reject each via existing per-transaction API

[misamikasa]

Proposal

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

When an approver opens an expense report in New Dot and opens More (three-dot menu), Reject does not appear in cases where it should (e.g. report with no expenses, or reports with 2+ expenses). Users report having to use Expensify Classic to reject. Repro is marked needs reproduction internally, but the code explains consistent hiding of Reject outside the single-transaction case.

What is the root cause of that problem?

1) UI hides Reject unless there is exactly one transaction

In src/components/MoneyReportHeader.tsx, the Reject secondary action includes:

• shouldShow: transactions.length === 1

So Reject is not shown when transactions.length === 0 or > 1, even if Reject is present in the secondary-actions list from ReportSecondaryActionUtils.

2) Reject flow is transaction-scoped, not report-scoped

rejectMoneyRequestReason in src/libs/ReportUtils.ts reads IOUTransactionID (and related fields) from a money request report action and navigates to the per-transaction reject reason route. For a report with no expenses, there may be no suitable transaction to attach this flow to—so exposing the button alone would not be enough without a report-level reject path.

3) Business logic still gates whether Reject is offered at all

canRejectReportAction in src/libs/ReportUtils.ts requires (among other checks) that the report is in processing/submitted state via isProcessingReport (stateNum / statusNum both submitted), that the current user is the manager, and excludes IOU/invoice cases. If an empty report is not in that state, Reject will not be added in src/libs/ReportSecondaryActionUtils.ts even before the More-menu filter.

Together: Layer 1 can omit Reject from the list; Layer 2 further hides it unless there is exactly one transaction; Layer 3 means the current implementation is built around one transaction, which does not cover empty or multi-expense reports without product/API alignment.

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

This needs a product decision on parity with Classic:

Option A — Report-level reject (match Classic for empty / multi-expense)

• Add a report-level reject flow (reason modal + API) that does not depend on a single IOUTransactionID.
• For 0 expenses: reject/return the report without opening the per-transaction reject screen.
• For 1 expense: keep current per-transaction flow if desired, or unify under report-level reject.
• For 2+ expenses: reject entire report, or document that approvers must use selection/bulk flows—product must specify.
• Update MoneyReportHeader so Reject shouldShow is not limited to transactions.length === 1 once the handler supports each case.

Option B — Minimal scope (empty reports only)

• Add a dedicated “Reject report” action only when transactions.length === 0 and canRejectReportAction is true, backed by a report-level API (or documented backend command).
• Leave multi-expense behavior unchanged or address in a follow-up.

Backend note: If no existing write command supports rejecting a report with zero linked transactions, this likely requires API/backend work in addition to App changes. The current rejectMoneyRequest-style path is oriented around transactions.

What alternative solutions did you explore? (Optional)

• Remove only shouldShow: transactions.length === 1: would show Reject for 0 or many transactions but onSelected still calls rejectMoneyRequestReason(requestParentReportAction)—likely broken or wrong for 0 transactions and ambiguous for 2+.
• Bulk selection flows may help for multiple expenses but do not help when there are no transactions to select.