Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -0,0 +1,69 @@
import {useMemo} from 'react';
import useCardFeedErrors from '@hooks/useCardFeedErrors';
import {getCardFeedWithDomainID, isDirectFeed} from '@libs/CardUtils';
import type {Policy} from '@src/types/onyx';

type BrokenCompanyCardConnection = {
/** The policy ID associated with this connection */
policyID: string;

/** The policy name associated with this connection */
policyName: string;

/** A representative card ID on this feed, used to render FixCompanyCardConnection */
cardID: string;

/** feedNameWithDomainID for this broken direct feed */
feedKey: string;
};

/**
* Returns at most one broken company card connection per direct (OAuth/Plaid) feed for workspaces
* where the current user is an admin. Commercial feeds (vcf/cdf/etc.) are excluded because they
* are file-based and not user-fixable via bank login.
*/
function useBrokenDirectCompanyCardFeedsForAdmin(adminPolicies: Policy[] | undefined): BrokenCompanyCardConnection[] {
const {cardsWithBrokenFeedConnection} = useCardFeedErrors();

return useMemo(() => {
if (!cardsWithBrokenFeedConnection || !adminPolicies) {
return [];
}

const brokenCompanyCardConnectionsByFeed = new Map<string, BrokenCompanyCardConnection>();

for (const card of Object.values(cardsWithBrokenFeedConnection)) {
if (!card?.fundID) {
continue;
}

// Only direct OAuth/Plaid feeds are user-fixable; commercial feeds (vcf/cdf/etc.) are file-based
if (!isDirectFeed(card.bank)) {
continue;
}

const cardFundID = Number(card.fundID);
const matchingPolicy = adminPolicies.find((policy) => policy.policyAccountID === cardFundID);

if (!matchingPolicy) {
continue;
}

const feedKey = getCardFeedWithDomainID(card.bank, card.fundID);
if (brokenCompanyCardConnectionsByFeed.has(feedKey)) {
continue;
}

brokenCompanyCardConnectionsByFeed.set(feedKey, {
policyID: matchingPolicy.id,
policyName: matchingPolicy.name,
cardID: String(card.cardID),
feedKey,
});
}

return Array.from(brokenCompanyCardConnectionsByFeed.values());
}, [adminPolicies, cardsWithBrokenFeedConnection]);
}

export default useBrokenDirectCompanyCardFeedsForAdmin;
40 changes: 3 additions & 37 deletions src/pages/home/TimeSensitiveSection/index.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,7 @@ import CONST from '@src/CONST';
import ONYXKEYS from '@src/ONYXKEYS';
import type {Policy} from '@src/types/onyx';
import type {ConnectionName, PolicyConnectionName} from '@src/types/onyx/Policy';
import useBrokenDirectCompanyCardFeedsForAdmin from './hooks/useBrokenDirectCompanyCardFeedsForAdmin';
import useTimeSensitiveAddPaymentCard from './hooks/useTimeSensitiveAddPaymentCard';
import useTimeSensitiveBilling from './hooks/useTimeSensitiveBilling';
import useTimeSensitiveCards from './hooks/useTimeSensitiveCards';
Expand Down Expand Up @@ -52,17 +53,6 @@ type BrokenPolicyConnection = {
integrationName: string;
};

type BrokenCompanyCardConnection = {
/** The policy ID associated with this connection */
policyID: string;

/** The policy name associated with this connection */
policyName: string;

/** The card ID associated with this connection */
cardID: string;
};

type BrokenPersonalCardConnection = {
/** The card ID associated with this connection */
cardID: string;
Expand Down Expand Up @@ -103,6 +93,7 @@ function TimeSensitiveSection() {

// Get card feed errors for company card connections (Release 4)
const cardFeedErrors = useCardFeedErrors();
const brokenCompanyCardConnections = useBrokenDirectCompanyCardFeedsForAdmin(adminPolicies);
Comment thread
mountiny marked this conversation as resolved.
Resolved

// Find policies with broken connections (accounting + HR, only for admins)
const brokenPolicyConnections: BrokenPolicyConnection[] = [];
Expand Down Expand Up @@ -132,31 +123,6 @@ function TimeSensitiveSection() {
}
}

// Get company cards with broken connections (for admins)
const brokenCompanyCardConnections: BrokenCompanyCardConnection[] = [];
const cardsWithBrokenConnection = cardFeedErrors.cardsWithBrokenFeedConnection;
if (cardsWithBrokenConnection && adminPolicies) {
for (const card of Object.values(cardsWithBrokenConnection)) {
if (!card?.fundID) {
continue;
}

// Find the policy associated with this card's fundID (workspaceAccountID)
const cardFundID = Number(card.fundID);
const matchingPolicy = adminPolicies.find((policy) => policy.policyAccountID === cardFundID);

if (!matchingPolicy) {
continue;
}

brokenCompanyCardConnections.push({
policyID: matchingPolicy.id,
policyName: matchingPolicy.name,
cardID: String(card.cardID),
});
}
}

// Get personal cards with broken connections
const brokenPersonalCardConnections: BrokenPersonalCardConnection[] = [];
const personalCardsWithBrokenConnection = cardFeedErrors.personalCardsWithBrokenConnection;
Expand Down Expand Up @@ -242,7 +208,7 @@ function TimeSensitiveSection() {
}
items.push(
<FixCompanyCardConnection
key={`company-card-${connection.cardID}`}
key={`company-card-${connection.feedKey}`}
card={card}
policyID={connection.policyID}
policyName={connection.policyName}
Expand Down
174 changes: 174 additions & 0 deletions tests/unit/hooks/useBrokenDirectCompanyCardFeedsForAdmin.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,174 @@
import {renderHook} from '@testing-library/react-native';
import {getCardFeedWithDomainID} from '@libs/CardUtils';
import useBrokenDirectCompanyCardFeedsForAdmin from '@pages/home/TimeSensitiveSection/hooks/useBrokenDirectCompanyCardFeedsForAdmin';
import CONST from '@src/CONST';
import type {Card, CardList} from '@src/types/onyx';
import type {CardFeedWithNumber} from '@src/types/onyx/CardFeeds';
import type {CardFeedErrors} from '@src/types/onyx/DerivedValues';
import type Policy from '@src/types/onyx/Policy';

const WORKSPACE_ACCOUNT_ID = 44444444;
const POLICY_ID = 'POLICY_1';
const POLICY_NAME = 'SPS Health';

const OAUTH_CHASE_FEED = CONST.COMPANY_CARD.FEED_BANK_NAME.CHASE;
const OAUTH_AMEX_FEED = CONST.COMPANY_CARD.FEED_BANK_NAME.AMEX_DIRECT;
const COMMERCIAL_VISA_FEED = CONST.COMPANY_CARD.FEED_BANK_NAME.VISA;

const DEFAULT_CARD_FEED_ERROR_STATE = {
shouldShowRBR: false,
hasFeedErrors: false,
hasWorkspaceErrors: false,
isFeedConnectionBroken: false,
};

function createDefaultCardFeedErrors(): CardFeedErrors {
return {
cardFeedErrors: {},
cardsWithBrokenFeedConnection: {},
personalCardsWithBrokenConnection: {},
shouldShowRbrForWorkspaceAccountID: {},
shouldShowRbrForFeedNameWithDomainID: {},
all: DEFAULT_CARD_FEED_ERROR_STATE,
companyCards: DEFAULT_CARD_FEED_ERROR_STATE,
expensifyCard: DEFAULT_CARD_FEED_ERROR_STATE,
personalCard: DEFAULT_CARD_FEED_ERROR_STATE,
};
}

const mockUseCardFeedErrors = jest.fn<CardFeedErrors, []>();

jest.mock('@hooks/useCardFeedErrors', () => ({
__esModule: true,
default: () => mockUseCardFeedErrors(),
}));

function createAdminPolicy(overrides: Partial<Policy> & {id: string} = {id: POLICY_ID}): Policy {
// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
return {
name: POLICY_NAME,
role: CONST.POLICY.ROLE.ADMIN,
type: CONST.POLICY.TYPE.TEAM,
isPolicyExpenseChatEnabled: true,
policyAccountID: WORKSPACE_ACCOUNT_ID,
...overrides,
} as Policy;
}

function createBrokenCard(cardID: number, bank: CardFeedWithNumber): Card {
return {
cardID,
accountID: 1,
bank,
cardName: 'Test Card',
domainName: 'test.exfy',
fraud: 'none',
fundID: String(WORKSPACE_ACCOUNT_ID),
lastFourPAN: '1234',
lastScrape: '',
lastScrapeResult: 403,
lastUpdated: '',
state: CONST.EXPENSIFY_CARD.STATE.OPEN,
};
}

function setMockBrokenCards(cardsWithBrokenFeedConnection: CardList) {
mockUseCardFeedErrors.mockReturnValue({
...createDefaultCardFeedErrors(),
cardsWithBrokenFeedConnection,
});
}

describe('useBrokenDirectCompanyCardFeedsForAdmin', () => {
const adminPolicies = [createAdminPolicy()];

beforeEach(() => {
mockUseCardFeedErrors.mockReturnValue(createDefaultCardFeedErrors());
});

it('returns one connection when multiple broken cards share the same direct feed', () => {
setMockBrokenCards({
card1: createBrokenCard(1, OAUTH_CHASE_FEED),
card2: createBrokenCard(2, OAUTH_CHASE_FEED),
card3: createBrokenCard(3, OAUTH_CHASE_FEED),
});

const {result} = renderHook(() => useBrokenDirectCompanyCardFeedsForAdmin(adminPolicies));

expect(result.current).toHaveLength(1);
expect(result.current.at(0)).toStrictEqual({
policyID: POLICY_ID,
policyName: POLICY_NAME,
cardID: '1',
feedKey: getCardFeedWithDomainID(OAUTH_CHASE_FEED, WORKSPACE_ACCOUNT_ID),
});
});

it('returns one connection per distinct direct feed', () => {
setMockBrokenCards({
card1: createBrokenCard(1, OAUTH_CHASE_FEED),
card2: createBrokenCard(2, OAUTH_AMEX_FEED),
});

const {result} = renderHook(() => useBrokenDirectCompanyCardFeedsForAdmin(adminPolicies));

expect(result.current).toHaveLength(2);
expect(result.current.map((connection) => connection.feedKey)).toStrictEqual([
getCardFeedWithDomainID(OAUTH_CHASE_FEED, WORKSPACE_ACCOUNT_ID),
getCardFeedWithDomainID(OAUTH_AMEX_FEED, WORKSPACE_ACCOUNT_ID),
]);
});

it('returns no connections for commercial feeds', () => {
setMockBrokenCards({
card1: createBrokenCard(1, COMMERCIAL_VISA_FEED),
card2: createBrokenCard(2, COMMERCIAL_VISA_FEED),
card3: createBrokenCard(3, COMMERCIAL_VISA_FEED),
});

const {result} = renderHook(() => useBrokenDirectCompanyCardFeedsForAdmin(adminPolicies));

expect(result.current).toHaveLength(0);
});

it('returns only direct feed connections when direct and commercial feeds are both broken', () => {
setMockBrokenCards({
card1: createBrokenCard(1, OAUTH_CHASE_FEED),
card2: createBrokenCard(2, OAUTH_CHASE_FEED),
card3: createBrokenCard(3, COMMERCIAL_VISA_FEED),
card4: createBrokenCard(4, COMMERCIAL_VISA_FEED),
});

const {result} = renderHook(() => useBrokenDirectCompanyCardFeedsForAdmin(adminPolicies));

expect(result.current).toHaveLength(1);
expect(result.current.at(0)?.feedKey).toBe(getCardFeedWithDomainID(OAUTH_CHASE_FEED, WORKSPACE_ACCOUNT_ID));
});

it('returns an empty array when admin policies are undefined', () => {
setMockBrokenCards({
card1: createBrokenCard(1, OAUTH_CHASE_FEED),
});

const {result} = renderHook(() => useBrokenDirectCompanyCardFeedsForAdmin(undefined));

expect(result.current).toStrictEqual([]);
});

it('skips cards without a matching admin workspace policy', () => {
setMockBrokenCards({
card1: createBrokenCard(1, OAUTH_CHASE_FEED),
});

const {result} = renderHook(() =>
useBrokenDirectCompanyCardFeedsForAdmin([
createAdminPolicy({
id: POLICY_ID,
policyAccountID: 99999999,
}),
]),
);

expect(result.current).toStrictEqual([]);
});
});
Loading