[Payment due @daledah] Load single default P2P mileage rate

src/ONYXKEYS.ts

@@ -6,6 +6,7 @@ import type {OnboardingCompanySize} from './libs/actions/Welcome/OnboardingFlow'
 import type Platform from './libs/getPlatform/types';
 import type * as FormTypes from './types/form';
 import type * as OnyxTypes from './types/onyx';
+import type DefaultP2PMileageRate from './types/onyx/DefaultP2PMileageRate';
 import type {Attendee, DistanceExpenseType, Participant} from './types/onyx/IOU';
 import type Onboarding from './types/onyx/Onboarding';
 import type {AnyOnyxUpdate} from './types/onyx/Request';
@@ -27,6 +28,9 @@ const ONYXKEYS = {
      * which tab is the leader, and which ones are the followers */
     ACTIVE_CLIENTS: 'activeClients',
 
+    /** Contains the default rate and unit to use for P2P distance expenses, based on the user's personal policy outputCurrency (default / report currency). */
+    DEFAULT_P2P_MILEAGE_RATE: 'defaultP2PMileageRate',
+
     /** A unique ID for the device */
     DEVICE_ID: 'deviceID',
 
@@ -1437,6 +1441,7 @@ type OnyxCollectionValuesMapping = {
 type OnyxValuesMapping = {
     [ONYXKEYS.ACCOUNT]: OnyxTypes.Account;
     [ONYXKEYS.ACCOUNT_MANAGER_REPORT_ID]: string;
+    [ONYXKEYS.DEFAULT_P2P_MILEAGE_RATE]: DefaultP2PMileageRate;
 
     [ONYXKEYS.NVP_ONBOARDING]: Onboarding;
 

src/libs/API/types.ts

@@ -1276,6 +1276,7 @@ type WriteCommandParameters = {
 };
 
 const READ_COMMANDS = {
+    GET_DEFAULT_P2P_MILEAGE_RATE: 'GetDefaultP2PMileageRate',
     GET_CORPAY_BANK_ACCOUNT_FIELDS: 'GetCorpayBankAccountFields',
     CONNECT_POLICY_TO_QUICKBOOKS_ONLINE: 'ConnectPolicyToQuickbooksOnline',
     CONNECT_POLICY_TO_XERO: 'ConnectPolicyToXero',
@@ -1380,6 +1381,7 @@ const READ_COMMANDS = {
 type ReadCommand = ValueOf<typeof READ_COMMANDS>;
 
 type ReadCommandParameters = {
+    [READ_COMMANDS.GET_DEFAULT_P2P_MILEAGE_RATE]: null;
     [READ_COMMANDS.CONNECT_POLICY_TO_QUICKBOOKS_ONLINE]: Parameters.ConnectPolicyToAccountingIntegrationParams;
     [READ_COMMANDS.CONNECT_POLICY_TO_XERO]: Parameters.ConnectPolicyToAccountingIntegrationParams;
     [READ_COMMANDS.CONNECT_POLICY_TO_GUSTO]: Parameters.ConnectPolicyToGustoParams;

src/libs/DistanceRequestUtils.ts

@@ -5,9 +5,11 @@ import type {LocaleContextProps} from '@components/LocaleContextProvider';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import type {LastSelectedDistanceRates, OnyxInputOrEntry, Transaction} from '@src/types/onyx';
+import type DefaultP2PMileageRate from '@src/types/onyx/DefaultP2PMileageRate';
 import type {Unit} from '@src/types/onyx/Policy';
 import type Policy from '@src/types/onyx/Policy';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
+import getStoredDefaultP2PMileageRate from './getStoredDefaultP2PMileageRate';
 import {replaceAllDigits} from './MoneyRequestUtils';
 import {getDistanceRateCustomUnit, getDistanceRateCustomUnitRate, getUnitRateValue} from './PolicyUtils';
 import {getCurrency, getRateID, isCustomUnitRateIDForP2P, isExpenseUnreported} from './TransactionUtils';
@@ -33,6 +35,7 @@ Onyx.connectWithoutView({
 
 const METERS_TO_KM = 0.001; // 1 kilometer is 1000 meters
 const METERS_TO_MILES = 0.000621371; // There are approximately 0.000621371 miles in a meter
+const DEFAULT_P2P_RATE_CENTS_PER_MILE = 67;
 
 function getMileageRates(policy: OnyxInputOrEntry<Policy>, includeDisabledRates = false, selectedRateID?: string): Record<string, MileageRate> {
     const mileageRates: Record<string, MileageRate> = {};
@@ -276,13 +279,6 @@ function getDistanceMerchant(
     return `${distanceInUnits} ${CONST.DISTANCE_MERCHANT_SEPARATOR} ${ratePerUnit}`;
 }
 
-function ensureRateDefined(rate: number | undefined): asserts rate is number {
-    if (rate !== undefined) {
-        return;
-    }
-    throw new Error('All default P2P rates should have a rate defined');
-}
-
 /**
  * Retrieves the rate and unit for a P2P distance expense for a given currency.
  *
@@ -292,16 +288,16 @@ function ensureRateDefined(rate: number | undefined): asserts rate is number {
  * @returns The rate and unit in MileageRate object.
  */
 function getRateForP2P(currency: string, transaction: OnyxEntry<Transaction>): MileageRate {
-    const currencyWithExistingRate = CONST.CURRENCY_TO_DEFAULT_MILEAGE_RATE[currency] ? currency : CONST.CURRENCY.USD;
-    const mileageRate = CONST.CURRENCY_TO_DEFAULT_MILEAGE_RATE[currencyWithExistingRate];
-    ensureRateDefined(mileageRate.rate);
+    const defaultRate = getStoredDefaultP2PMileageRate();
+    const p2pRate: DefaultP2PMileageRate = defaultRate ?? {rate: DEFAULT_P2P_RATE_CENTS_PER_MILE, unit: CONST.CUSTOM_UNITS.DISTANCE_UNIT_MILES};
+    const rate = transaction && getCurrency(transaction) === currency ? (transaction.comment?.customUnit?.defaultP2PRate ?? p2pRate.rate) : p2pRate.rate;
 
-    // Ensure the rate is updated when the currency changes, otherwise use the stored rate
-    const rate = getCurrency(transaction) === currency ? (transaction?.comment?.customUnit?.defaultP2PRate ?? mileageRate.rate) : mileageRate.rate;
+    // If a distance expense is being edited, the defaultP2PRate may not have been loaded yet, so use data from the existing transaction.
+    const fallbackUnit = transaction?.comment?.customUnit?.distanceUnit ?? CONST.CUSTOM_UNITS.DISTANCE_UNIT_MILES;
     return {
-        ...mileageRate,
-        currency: currencyWithExistingRate,
         rate,
+        unit: defaultRate ? p2pRate.unit : fallbackUnit,
+        currency: defaultRate ? currency : getCurrency(transaction),
     };
 }
 

src/libs/actions/IOU/MoneyRequest.ts

@@ -28,6 +28,7 @@ import {
     isOdometerDistanceRequest as isOdometerDistanceRequestTransactionUtils,
 } from '@libs/TransactionUtils';
 import type {ReceiptFile} from '@pages/iou/request/step/IOURequestStepScan/types';
+import {getDefaultP2PMileageRate} from '@userActions/Transaction';
 import {getRemoveDraftTransactionsByIDsData, removeDraftTransactionsByIDs} from '@userActions/TransactionEdit';
 import type {IOURequestType} from '@src/CONST';
 import CONST from '@src/CONST';
@@ -440,6 +441,7 @@ function startDistanceRequest(
     backToReport?: string,
     isFromFloatingActionButton?: boolean,
 ) {
+    getDefaultP2PMileageRate();
     clearMoneyRequest(CONST.IOU.OPTIMISTIC_TRANSACTION_ID, draftTransactionIDs, skipConfirmation);
     if (isFromFloatingActionButton) {
         Onyx.set(`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${CONST.IOU.OPTIMISTIC_TRANSACTION_ID}`, {isFromFloatingActionButton});

src/libs/actions/Transaction.ts

@@ -1810,6 +1810,10 @@ function changeTransactionsReport({
     });
 }
 
+function getDefaultP2PMileageRate() {
+    API.read(READ_COMMANDS.GET_DEFAULT_P2P_MILEAGE_RATE, null);
+}
+
 function mergeTransactionIdsHighlightOnSearchRoute(type: SearchDataTypes, data: Record<string, boolean> | null) {
     return Onyx.merge(ONYXKEYS.TRANSACTION_IDS_HIGHLIGHT_ON_SEARCH_ROUTE, {[type]: data});
 }
@@ -1845,6 +1849,7 @@ export {
     revert,
     changeTransactionsReport,
     setTransactionReport,
+    getDefaultP2PMileageRate,
     mergeTransactionIdsHighlightOnSearchRoute,
     getDuplicateTransactionDetails,
 };

src/libs/getStoredDefaultP2PMileageRate/index.ts

@@ -0,0 +1,24 @@
+// This module is used to load the default P2P mileage rate for a user based on their personal policy outputCurrency (default / reporting currency).
+// Whenever a user starts the "Track distance" flow the getDefaultP2PMileageRate action will fetch the rate and unit from the hard coded mapping stored in Auth
+// (CURRENCY_TO_DEFAULT_MILEAGE_RATE), via the API read command GetDefaultP2PMileageRate.
+// The rate will be stored in Onyx and loaded into a variable here via Onyx.connectWithoutView. Normally useOnyx should be used instead, but because
+// the default P2P mileage rate is used across many library functions an exception is allowed to prevent having to pass the value through many functions
+// across the codebase.
+// DO NOT use this pattern for other Onyx data unless you get authorization from the internal Expensify team in Slack.
+import Onyx from 'react-native-onyx';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type DefaultP2PMileageRate from '@src/types/onyx/DefaultP2PMileageRate';
+
+let defaultP2PMileageRate: DefaultP2PMileageRate | undefined;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.DEFAULT_P2P_MILEAGE_RATE,
+    callback: (value) => {
+        defaultP2PMileageRate = value;
+    },
+});
+
+function getStoredDefaultP2PMileageRate() {
+    return defaultP2PMileageRate;
+}
+
+export default getStoredDefaultP2PMileageRate;

src/types/onyx/DefaultP2PMileageRate.ts

@@ -0,0 +1,12 @@
+import type {Unit} from './Policy';
+
+/** Default P2P mileage rate fetched from Auth for the user's personal policy outputCurrency (default / report currency) */
+type DefaultP2PMileageRate = {
+    /** Rate in cents per unit (e.g. 67 = $0.67/mile) */
+    rate: number;
+
+    /** Distance unit: "mi" or "km" */
+    unit: Unit;
+};
+
+export default DefaultP2PMileageRate;

tests/unit/DefaultP2PMileageRateTest.ts

@@ -0,0 +1,70 @@
+import Onyx from 'react-native-onyx';
+import {getDefaultP2PMileageRate} from '@libs/actions/Transaction';
+import * as API from '@libs/API';
+import {READ_COMMANDS} from '@libs/API/types';
+import DistanceRequestUtils from '@libs/DistanceRequestUtils';
+import getStoredDefaultP2PMileageRate from '@libs/getStoredDefaultP2PMileageRate';
+import CONST from '@src/CONST';
+import ONYXKEYS from '@src/ONYXKEYS';
+import createRandomTransaction from '../utils/collections/transaction';
+import waitForBatchedUpdates from '../utils/waitForBatchedUpdates';
+
+describe('Default P2P mileage rate', () => {
+    beforeAll(() => {
+        Onyx.init({
+            keys: ONYXKEYS,
+        });
+    });
+
+    beforeEach(() => {
+        return Onyx.clear().then(waitForBatchedUpdates);
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('getDefaultP2PMileageRate', () => {
+        it('calls API.read with GetDefaultP2PMileageRate', () => {
+            const readSpy = jest.spyOn(API, 'read').mockImplementation(() => {});
+
+            getDefaultP2PMileageRate();
+
+            expect(readSpy).toHaveBeenCalledWith(READ_COMMANDS.GET_DEFAULT_P2P_MILEAGE_RATE, null);
+        });
+    });
+
+    describe('getRateForP2P', () => {
+        it('falls back to USD 67¢/mile when no rate has been stored in Onyx', () => {
+            const result = DistanceRequestUtils.getRateForP2P('EUR', undefined);
+
+            expect(result).toEqual({rate: 67, unit: 'mi', currency: CONST.CURRENCY.USD});
+        });
+
+        it('uses the stored Onyx rate with the caller currency once a rate is available', async () => {
+            await Onyx.set(ONYXKEYS.DEFAULT_P2P_MILEAGE_RATE, {rate: 5500, unit: CONST.CUSTOM_UNITS.DISTANCE_UNIT_KILOMETERS});
+            await waitForBatchedUpdates();
+
+            expect(getStoredDefaultP2PMileageRate()).toEqual({rate: 5500, unit: 'km'});
+
+            const result = DistanceRequestUtils.getRateForP2P('EUR', undefined);
+
+            expect(result).toEqual({rate: 5500, unit: 'km', currency: 'EUR'});
+        });
+
+        it('uses the transaction defaultP2PRate when the transaction currency matches', async () => {
+            await Onyx.set(ONYXKEYS.DEFAULT_P2P_MILEAGE_RATE, {rate: 5500, unit: CONST.CUSTOM_UNITS.DISTANCE_UNIT_MILES});
+            await waitForBatchedUpdates();
+
+            const transaction = {
+                ...createRandomTransaction(1),
+                currency: CONST.CURRENCY.USD,
+                comment: {customUnit: {defaultP2PRate: 99}},
+            };
+
+            const result = DistanceRequestUtils.getRateForP2P(CONST.CURRENCY.USD, transaction);
+
+            expect(result).toEqual({rate: 99, unit: 'mi', currency: CONST.CURRENCY.USD});
+        });
+    });
+});

tests/unit/DistanceRequestUtilsTest.ts

@@ -2,6 +2,7 @@ import DistanceRequestUtils from '@libs/DistanceRequestUtils';
 import CONST from '@src/CONST';
 import type {Unit} from '@src/types/onyx/Policy';
 import type Policy from '@src/types/onyx/Policy';
+import type Transaction from '@src/types/onyx/Transaction';
 import createRandomTransaction from '../utils/collections/transaction';
 import {translateLocal} from '../utils/TestHelper';
 
@@ -214,6 +215,39 @@ describe('DistanceRequestUtils', () => {
         });
     });
 
+    describe('getRateForP2P', () => {
+        // These tests run with the default P2P mileage rate unloaded (it's fetched asynchronously when a
+        // distance request starts), which is the case for flows that don't start a new distance request,
+        // such as editing an existing distance expense.
+        it('falls back to the existing transaction currency and unit when the default P2P rate is not loaded', () => {
+            // Given an existing P2P distance expense in GBP measured in kilometers, with its own saved rate
+            const transaction = {
+                ...createRandomTransaction(1),
+                currency: 'GBP',
+                comment: {customUnit: {distanceUnit: CONST.CUSTOM_UNITS.DISTANCE_UNIT_KILOMETERS, defaultP2PRate: 45}},
+            } as Transaction;
+
+            // When reading the P2P rate for that transaction's currency
+            const result = DistanceRequestUtils.getRateForP2P('GBP', transaction);
+
+            // Then it preserves the transaction's currency, unit, and saved rate instead of flipping to USD/miles
+            expect(result.currency).toBe('GBP');
+            expect(result.unit).toBe(CONST.CUSTOM_UNITS.DISTANCE_UNIT_KILOMETERS);
+            expect(result.rate).toBe(45);
+        });
+
+        it('falls back to USD and miles for a brand-new request with no transaction', () => {
+            // Given a brand-new distance request that has no transaction yet
+            // When reading the P2P rate
+            const result = DistanceRequestUtils.getRateForP2P('GBP', undefined);
+
+            // Then it falls back to the hardcoded USD/miles default
+            expect(result.currency).toBe(CONST.CURRENCY.USD);
+            expect(result.unit).toBe(CONST.CUSTOM_UNITS.DISTANCE_UNIT_MILES);
+            expect(result.rate).toBe(67);
+        });
+    });
+
     describe('getDistanceMerchant', () => {
         const toLocaleDigitMock = (dot: string): string => dot;
         const getCurrencySymbolMock = (currency: string): string | undefined => {