bank-statement-api / befree-frontend /hooks /useStatementAPI.ts
pratik-befree's picture
practices added for the classification
c58f0d0
Raw History Blame Contribute Delete
23.7 kB
import {
useQuery,
useMutation,
useQueryClient,
} from '@tanstack/react-query';
import { apiClient } from '@/services/api-client';
import type { AppSettings, ExportRequest, TransactionRowModel, HistoryRow, ActivityItem, DashboardMetrics, ReviewMetrics, ReviewSession, ProcessingStatus } from '@/types';
import type { CategoryRecord, RuleRecord, CategoryCreatePayload, CategoryUpdatePayload, RuleCreatePayload, RuleUpdatePayload, GroupRecord, RuleChangeRequestPayload, RuleChangeRequestRecord } from '@/services/api-client';
// Keys
export const statementKeys = {
all: ['statements'] as const,
detail: (id: string) => [...statementKeys.all, 'detail', id] as const,
transactions: (id: string) => [...statementKeys.detail(id), 'transactions'] as const,
status: (id: string) => [...statementKeys.detail(id), 'status'] as const,
flagged: (id: string) => [...statementKeys.detail(id), 'flagged'] as const,
export: (id: string) => [...statementKeys.detail(id), 'export'] as const,
reviewMetrics: (id: string) => [...statementKeys.detail(id), 'review-metrics'] as const,
history: () => ['history', 'statements'] as const,
settings: () => ['settings'] as const,
dashboardMetrics: () => ['dashboard', 'metrics'] as const,
dashboardActivity: () => ['dashboard', 'activity'] as const,
dashboardStatements: () => ['dashboard', 'statements'] as const,
// Classification rules / categories (DB-backed)
categories: () => ['admin', 'categories'] as const,
groups: () => ['admin', 'groups'] as const,
rules: (filters?: Record<string, string | boolean>) => ['admin', 'rules', filters ?? {}] as const,
};
// ── Existing queries (unchanged) ──────────────────────────────────────────────
export const useReviewSession = (statementId: string | null, enabled = true) => {
return useQuery({
queryKey: statementId ? statementKeys.detail(statementId) : ['null'],
queryFn: () =>
statementId ? apiClient.loadReviewSession(statementId) : null,
enabled: enabled && !!statementId,
staleTime: 5 * 60 * 1000,
});
};
export const useProcessingStatus = (statementId: string, enabled = true) => {
return useQuery<ProcessingStatus>({
queryKey: statementKeys.status(statementId),
queryFn: () => apiClient.getProcessingStatus(statementId),
enabled: enabled && !!statementId,
refetchInterval: (query) => {
if (!enabled || !statementId) return false;
const data = query.state.data;
if (data && (data.overallProgress === 100 || data.error)) {
return false;
}
const updateCount = query.state.dataUpdateCount || 0;
return Math.min(1000 + updateCount * 500, 10000); // Decays from 1s to 10s max
},
});
};
export const useTransactions = (
statementId: string,
options?: {
page?: number;
pageSize?: number;
pageNum?: number;
search?: string;
status?: string;
txType?: string;
confidence?: string;
},
enabled = true
) => {
return useQuery<{ items: TransactionRowModel[]; total: number; page: number; totalPages: number }>({
queryKey: [...statementKeys.transactions(statementId), options || {}],
queryFn: () => apiClient.getTransactions(statementId, options),
enabled: enabled && !!statementId,
staleTime: 2 * 60 * 1000,
});
};
export const useFlaggedTransactions = (
statementId: string | null,
params?: {
severity?: string;
bank?: string;
from?: string;
to?: string;
search?: string;
},
enabled = true
) => {
return useQuery<TransactionRowModel[] | null>({
queryKey: statementId ? statementKeys.flagged(statementId) : ['null'],
queryFn: () =>
statementId ? apiClient.getFlaggedTransactions(statementId, params) : null,
enabled: enabled && !!statementId,
});
};
export const useStatementHistory = (enabled = true) => {
return useQuery<HistoryRow[]>({
queryKey: statementKeys.history(),
queryFn: () => apiClient.getHistory(),
enabled,
staleTime: 10 * 60 * 1000,
});
};
export const useSettings = (enabled = true) => {
return useQuery<AppSettings>({
queryKey: statementKeys.settings(),
queryFn: () => apiClient.getSettings(),
enabled,
staleTime: 30 * 60 * 1000,
});
};
export const usePractices = (enabled = true) => {
return useQuery<{ practices: { id: string; name: string }[] }>({
queryKey: ['practices'],
queryFn: () => apiClient.getPractices(),
enabled,
staleTime: Infinity,
});
};
export const useReviewMetrics = (statementId: string | null, enabled = true) => {
return useQuery({
queryKey: statementId ? statementKeys.reviewMetrics(statementId) : ['null'],
queryFn: () =>
statementId ? apiClient.getReviewMetrics(statementId) : null,
enabled: enabled && !!statementId,
staleTime: 2 * 60 * 1000,
});
};
export const useDashboardMetrics = (enabled = true) => {
return useQuery<DashboardMetrics>({
queryKey: statementKeys.dashboardMetrics(),
queryFn: () => apiClient.getDashboardMetrics(),
enabled,
staleTime: 2 * 60 * 1000,
});
};
export const useDashboardActivity = (enabled = true) => {
return useQuery<ActivityItem[]>({
queryKey: statementKeys.dashboardActivity(),
queryFn: () => apiClient.getRecentActivity(),
enabled,
staleTime: 2 * 60 * 1000,
});
};
export const useDashboardStatements = (enabled = true) => {
return useQuery<HistoryRow[]>({
queryKey: statementKeys.dashboardStatements(),
queryFn: () => apiClient.getRecentStatements(),
enabled,
staleTime: 2 * 60 * 1000,
});
};
// ── Existing mutations (unchanged) ────────────────────────────────────────────
export const useUploadStatement = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: ({
formData,
onUploadProgress,
}: {
formData: FormData;
onUploadProgress?: (percent: number) => void;
}) => apiClient.uploadStatement(formData, onUploadProgress),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.history() });
},
});
};
export const useUploadExcel = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: ({
formData,
onUploadProgress,
}: {
formData: FormData;
onUploadProgress?: (percent: number) => void;
}) => apiClient.uploadExcel(formData, onUploadProgress),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.history() });
},
});
};
export const useStartProcessing = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (statementId: string) => apiClient.startProcessing(statementId),
onSuccess: (_, statementId) => {
queryClient.invalidateQueries({ queryKey: statementKeys.status(statementId) });
},
});
};
export const useCreateTransaction = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, any>) =>
apiClient.addTransaction(statementId, data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.reviewMetrics(statementId) });
},
});
};
export const useUpdateTransaction = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: ({ txId, data }: { txId: string; data: Record<string, any> }) =>
apiClient.updateTransaction(statementId, txId, data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.reviewMetrics(statementId) });
},
});
};
export const useDeleteTransaction = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (txId: string) => apiClient.deleteTransaction(statementId, txId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.reviewMetrics(statementId) });
},
});
};
export const useAutoSwapAll = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: () => apiClient.autoSwapAll(statementId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.reviewMetrics(statementId) });
},
});
};
export const useSwapDebitCredit = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (txId: string) => apiClient.swapDebitCredit(statementId, txId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.reviewMetrics(statementId) });
},
});
};
export const useReAuditPage = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (pageNum: number) => apiClient.reAuditPage(statementId, pageNum),
onSuccess: () => {
queryClient.refetchQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.reviewMetrics(statementId) });
},
});
};
export const useReviewPage = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (pageNum: number) => apiClient.reviewPage(statementId, pageNum),
onSuccess: () => {
// Use refetchQueries (not invalidateQueries) so the table updates
// immediately without waiting for the staleTime window to expire.
queryClient.refetchQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.reviewMetrics(statementId) });
},
});
};
export const useReopenStatement = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (statementId: string) => apiClient.reopenStatement(statementId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.history() });
},
});
};
export const useDuplicateStatement = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (statementId: string) => apiClient.duplicateStatement(statementId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.history() });
},
});
};
export const useDeleteStatement = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (statementId: string) => apiClient.deleteStatement(statementId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.history() });
queryClient.invalidateQueries({ queryKey: statementKeys.dashboardStatements() });
},
});
};
export const useExportSummary = (statementId: string | null, enabled = true) => {
return useQuery({
queryKey: statementId ? statementKeys.export(statementId) : ['null'],
queryFn: () =>
statementId ? apiClient.getExportSummary(statementId) : null,
enabled: enabled && !!statementId,
staleTime: 2 * 60 * 1000,
});
};
export const useGenerateExport = (statementId: string) => {
return useMutation({
mutationFn: (options: ExportRequest) =>
apiClient.generateExport(statementId, options),
});
};
export const useUpdateSettings = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (settings: AppSettings) => apiClient.updateSettings(settings),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.settings() });
},
});
};
export const useClassifyStatement = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: () => apiClient.classifyStatement(statementId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.reviewMetrics(statementId) });
},
});
};
export const useFinaliseStatement = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (payload?: { extract_last_3_months: boolean; practice_ids?: string[] }) =>
apiClient.finaliseStatement(statementId, payload),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.detail(statementId) });
queryClient.invalidateQueries({ queryKey: statementKeys.history() });
},
});
};
export const useClassifyStatus = (statementId: string | null, enabled = true) => {
return useQuery({
queryKey: statementId ? ['statement', statementId, 'classify-status'] : ['null'],
queryFn: () => (statementId ? apiClient.getClassifyStatus(statementId) : null),
enabled: enabled && !!statementId,
refetchInterval: (query) => {
if (!enabled || !statementId) return false;
const data = query.state.data;
if (data && (data.status === 'completed' || data.status === 'failed')) {
return false;
}
const updateCount = query.state.dataUpdateCount || 0;
return Math.min(2000 + updateCount * 1000, 15000); // Decays from 2s to 15s max
},
});
};
export const useUpdateClassifyOverride = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: ({ txId, category }: { txId: string; category: string }) =>
apiClient.updateClassifyOverride(statementId, txId, category),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: ['statement', statementId, 'classify-status'] });
},
});
};
export const useConfirmClassifySuggestion = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (txId: string) => apiClient.confirmClassifySuggestion(statementId, txId),
onSuccess: (data: { verifiedIds?: string[]; count?: number; bulkApplied?: boolean } | null) => {
if (data?.verifiedIds && data.verifiedIds.length > 0) {
const verifiedSet = new Set<string>(data.verifiedIds);
queryClient.setQueriesData<{ items: TransactionRowModel[] }>(
{ queryKey: statementKeys.transactions(statementId) },
(old) =>
old && {
...old,
items: old.items.map((tx) =>
verifiedSet.has(tx.id) ? { ...tx, verified: true } : tx
),
}
);
}
},
onSettled: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
},
});
};
export const useConfirmClassifySuggestionsBulk = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (txIds: string[]) => apiClient.confirmClassifySuggestionsBulk(statementId, txIds),
onSuccess: (data: { verifiedIds?: string[]; count?: number } | null) => {
if (data?.verifiedIds && data.verifiedIds.length > 0) {
const verifiedSet = new Set<string>(data.verifiedIds);
queryClient.setQueriesData<{ items: TransactionRowModel[] }>(
{ queryKey: statementKeys.transactions(statementId) },
(old) =>
old && {
...old,
items: old.items.map((tx) =>
verifiedSet.has(tx.id) ? { ...tx, verified: true } : tx
),
}
);
}
},
onSettled: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
},
});
};
export const useResetClassifyOverride = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (txId: string) => apiClient.resetClassifyOverride(statementId, txId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.transactions(statementId) });
queryClient.invalidateQueries({ queryKey: ['statement', statementId, 'classify-status'] });
},
});
};
// ── NEW: DB-backed Categories ─────────────────────────────────────────────────
/**
* Fetch all classification categories from the DB.
* Any authenticated user can call this (needed for the preset-rules modal).
* Admin users can pass includeInactive=true.
*/
export const useCategories = (includeInactive = false, enabled = true) => {
return useQuery<{ items: CategoryRecord[]; total: number }>({
queryKey: [...statementKeys.categories(), { includeInactive }],
queryFn: () => apiClient.getCategories(includeInactive),
enabled,
staleTime: 5 * 60 * 1000,
});
};
/** Fetch all active groups from the DB. */
export const useGroups = (enabled = true) => {
return useQuery<{ items: GroupRecord[]; total: number }>({
queryKey: statementKeys.groups(),
queryFn: () => apiClient.getGroups(),
enabled,
staleTime: 5 * 60 * 1000,
});
};
/** Admin: create a new category. */
export const useCreateCategory = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (payload: CategoryCreatePayload) => apiClient.createCategory(payload),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.categories() });
},
});
};
/** Admin: update an existing category (name, sheet, is_active). */
export const useUpdateCategory = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: ({ id, payload }: { id: string; payload: CategoryUpdatePayload }) =>
apiClient.updateCategory(id, payload),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.categories() });
},
});
};
/** Admin: soft-delete a category. */
export const useDeleteCategory = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (id: string) => apiClient.deleteCategory(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: statementKeys.categories() });
},
});
};
// ── NEW: DB-backed Rules ──────────────────────────────────────────────────────
/**
* Fetch all active classification rules.
* Any authenticated user can read (modal needs it).
*/
export const useRules = (
filters?: { category_id?: string; match_on?: string; include_inactive?: boolean },
enabled = true
) => {
return useQuery<{ items: RuleRecord[]; total: number }>({
queryKey: statementKeys.rules(filters),
queryFn: () => apiClient.getRules(filters),
enabled,
staleTime: 5 * 60 * 1000,
});
};
/** Admin: create a new rule. */
export const useCreateRule = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (payload: RuleCreatePayload) => apiClient.createRule(payload),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['admin', 'rules'] });
},
});
};
/** Admin: update an existing rule. */
export const useUpdateRule = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: ({ id, payload }: { id: string; payload: RuleUpdatePayload }) =>
apiClient.updateRule(id, payload),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['admin', 'rules'] });
},
});
};
/** Admin: hard-delete a rule. */
export const useDeleteRule = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (id: string) => apiClient.deleteRule(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['admin', 'rules'] });
},
});
};
export const useLayout = (statementId: string, enabled = true) => {
return useQuery({
queryKey: ['statements', statementId, 'layout'],
queryFn: () => apiClient.getLayout(statementId),
enabled: enabled && !!statementId,
});
};
export const useVerifyLayout = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (payload: { columns: any[]; header_page: number }) =>
apiClient.verifyLayout(statementId, payload),
onSuccess: () => {
queryClient.setQueryData(statementKeys.status(statementId), (old: any) => {
return {
...old,
status: 'extracting',
overallProgress: 60,
};
});
queryClient.invalidateQueries({ queryKey: statementKeys.status(statementId) });
},
});
};
export const usePatchLayoutColumn = (statementId: string) => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: ({ colName, payload }: { colName: string; payload: { x_min: number; x_max: number; header_label: string } }) =>
apiClient.patchLayoutColumn(statementId, colName, payload),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['statements', statementId, 'layout'] });
},
});
};
// ── NEW: Rule change requests ───────────────────────────────────────────────
export const useRuleRequests = (status?: string, enabled = true) => {
return useQuery<{ items: RuleChangeRequestRecord[]; total: number }>({
queryKey: ['rule-requests', status],
queryFn: () => apiClient.getRuleRequests(status),
enabled,
staleTime: 1 * 60 * 1000,
});
};
export const useCreateRuleRequest = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (payload: RuleChangeRequestPayload) => apiClient.createRuleRequest(payload),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['rule-requests'] });
},
});
};
export const useReviewRuleRequest = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: ({ requestId, action, review_note }: { requestId: string; action: 'approve' | 'reject'; review_note?: string }) =>
apiClient.reviewRuleRequest(requestId, action, review_note),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['rule-requests'] });
queryClient.invalidateQueries({ queryKey: ['admin', 'rules'] });
queryClient.invalidateQueries({ queryKey: ['admin', 'categories'] });
},
});
};
export const useDeleteRuleRequest = () => {
const queryClient = useQueryClient();
return useMutation({
mutationFn: (id: string) => apiClient.deleteRuleRequest(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['rule-requests'] });
},
});
};