Spaces:
Sleeping
Sleeping
Download befree-frontend/hooks/useStatementAPI.ts from Coeinterns/bank-statement-api: direct link, hf CLI and curl.
- Browser
- Download file 23.7 kB
-
https://huggingface.co/spaces/Coeinterns/bank-statement-api/resolve/main/befree-frontend/hooks/useStatementAPI.ts
- Command line
-
hf download hf://spaces/Coeinterns/bank-statement-api/befree-frontend/hooks/useStatementAPI.ts
-
curl -L -o useStatementAPI.ts https://huggingface.co/spaces/Coeinterns/bank-statement-api/resolve/main/befree-frontend/hooks/useStatementAPI.ts
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'] }); | |
| }, | |
| }); | |
| }; |