260220:1504 20260220 TASK-BEFE-001 Refactor by ADR-014

frontend/hooks/use-numbering.ts

@@ -0,0 +1,83 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { documentNumberingService } from '@/lib/services/document-numbering.service';
+import { numberingApi, NumberingTemplate } from '@/lib/api/numbering';
+import { ManualOverrideDto, VoidReplaceDto, CancelNumberDto, AuditQueryParams } from '@/types/dto/numbering.dto';
+
+export const numberingKeys = {
+  all: ['numbering'] as const,
+  templates: () => [...numberingKeys.all, 'templates'] as const,
+  metrics: () => [...numberingKeys.all, 'metrics'] as const,
+  auditLogs: (params?: AuditQueryParams) => [...numberingKeys.all, 'auditLogs', params] as const,
+};
+
+export const useTemplates = () => {
+  return useQuery({
+    queryKey: numberingKeys.templates(),
+    queryFn: () => numberingApi.getTemplates(),
+  });
+};
+
+export const useSaveTemplate = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: Partial<NumberingTemplate>) => numberingApi.saveTemplate(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: numberingKeys.templates() });
+    },
+  });
+};
+
+export const useNumberingMetrics = () => {
+  return useQuery({
+    queryKey: numberingKeys.metrics(),
+    queryFn: () => documentNumberingService.getMetrics(),
+  });
+};
+
+export const useNumberingAuditLogs = (params?: AuditQueryParams) => {
+  return useQuery({
+    queryKey: numberingKeys.auditLogs(params),
+    queryFn: () => documentNumberingService.getAuditLogs(params),
+  });
+};
+
+export const useManualOverrideNumbering = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: ManualOverrideDto) => documentNumberingService.manualOverride(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: numberingKeys.metrics() });
+      queryClient.invalidateQueries({ queryKey: numberingKeys.all }); // depending on keys
+    },
+  });
+};
+
+export const useVoidAndReplaceNumbering = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: VoidReplaceDto) => documentNumberingService.voidAndReplace(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: numberingKeys.all });
+    },
+  });
+};
+
+export const useCancelNumbering = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: CancelNumberDto) => documentNumberingService.cancelNumber(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: numberingKeys.all });
+    },
+  });
+};
+
+export const useBulkImportNumbering = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: FormData | any[]) => documentNumberingService.bulkImport(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: numberingKeys.all });
+    },
+  });
+};

frontend/hooks/use-reference-data.ts

@@ -0,0 +1,113 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { masterDataService } from '@/lib/services/master-data.service';
+
+export const referenceDataKeys = {
+  all: ['reference-data'] as const,
+  rfaTypes: (contractId?: number) => [...referenceDataKeys.all, 'rfaTypes', contractId] as const,
+  disciplines: (contractId?: number) => [...referenceDataKeys.all, 'disciplines', contractId] as const,
+  correspondenceTypes: () => [...referenceDataKeys.all, 'correspondenceTypes'] as const,
+};
+
+// --- RFA Types ---
+export const useRfaTypes = (contractId?: number) => {
+  return useQuery({
+    queryKey: referenceDataKeys.rfaTypes(contractId),
+    queryFn: () => masterDataService.getRfaTypes(contractId),
+  });
+};
+
+export const useCreateRfaType = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: any) => masterDataService.createRfaType(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['reference-data', 'rfaTypes'] });
+    },
+  });
+};
+
+export const useUpdateRfaType = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }: { id: number; data: any }) => masterDataService.updateRfaType(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['reference-data', 'rfaTypes'] });
+    },
+  });
+};
+
+export const useDeleteRfaType = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: number) => masterDataService.deleteRfaType(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['reference-data', 'rfaTypes'] });
+    },
+  });
+};
+
+// --- Disciplines ---
+export const useDisciplines = (contractId?: number) => {
+  return useQuery({
+    queryKey: referenceDataKeys.disciplines(contractId),
+    queryFn: () => masterDataService.getDisciplines(contractId),
+  });
+};
+
+export const useCreateDiscipline = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: any) => masterDataService.createDiscipline(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['reference-data', 'disciplines'] });
+    },
+  });
+};
+
+export const useDeleteDiscipline = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: number) => masterDataService.deleteDiscipline(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['reference-data', 'disciplines'] });
+    },
+  });
+};
+
+// --- Correspondence Types ---
+export const useCorrespondenceTypes = () => {
+  return useQuery({
+    queryKey: referenceDataKeys.correspondenceTypes(),
+    queryFn: () => masterDataService.getCorrespondenceTypes(),
+  });
+};
+
+export const useCreateCorrespondenceType = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: any) => masterDataService.createCorrespondenceType(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['reference-data', 'correspondenceTypes'] });
+    },
+  });
+};
+
+export const useUpdateCorrespondenceType = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }: { id: number; data: any }) => masterDataService.updateCorrespondenceType(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['reference-data', 'correspondenceTypes'] });
+    },
+  });
+};
+
+export const useDeleteCorrespondenceType = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: number) => masterDataService.deleteCorrespondenceType(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['reference-data', 'correspondenceTypes'] });
+    },
+  });
+};

frontend/hooks/use-workflows.ts

@@ -0,0 +1,78 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { workflowEngineService } from '@/lib/services/workflow-engine.service';
+import {
+  CreateWorkflowDefinitionDto,
+  UpdateWorkflowDefinitionDto,
+  EvaluateWorkflowDto,
+  GetAvailableActionsDto,
+} from '@/types/dto/workflow-engine/workflow-engine.dto';
+
+export const workflowKeys = {
+  all: ['workflows'] as const,
+  definitions: () => [...workflowKeys.all, 'definitions'] as const,
+  definition: (id: string | number) => [...workflowKeys.definitions(), id] as const,
+};
+
+export const useWorkflowDefinitions = () => {
+  return useQuery({
+    queryKey: workflowKeys.definitions(),
+    queryFn: () => workflowEngineService.getDefinitions(),
+  });
+};
+
+export const useWorkflowDefinition = (id: string | number) => {
+  return useQuery({
+    queryKey: workflowKeys.definition(id),
+    queryFn: () => workflowEngineService.getDefinitionById(id),
+    enabled: !!id,
+  });
+};
+
+export const useCreateWorkflowDefinition = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: CreateWorkflowDefinitionDto) => workflowEngineService.createDefinition(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: workflowKeys.definitions() });
+    },
+  });
+};
+
+export const useUpdateWorkflowDefinition = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string | number; data: UpdateWorkflowDefinitionDto }) =>
+      workflowEngineService.updateDefinition(id, data),
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: workflowKeys.definitions() });
+      queryClient.invalidateQueries({ queryKey: workflowKeys.definition(variables.id) });
+    },
+  });
+};
+
+export const useDeleteWorkflowDefinition = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string | number) => workflowEngineService.deleteDefinition(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: workflowKeys.definitions() });
+    },
+  });
+};
+
+/**
+ * Since this is a POST request, we use mutation. If you prefer to use useQuery,
+ * you would need to adjust the service to use GET (if possible) or pass the body via queryKey.
+ * For now, using useMutation for actions evaluation.
+ */
+export const useEvaluateWorkflow = () => {
+  return useMutation({
+    mutationFn: (data: EvaluateWorkflowDto) => workflowEngineService.evaluate(data),
+  });
+};
+
+export const useGetAvailableActions = () => {
+  return useMutation({
+    mutationFn: (data: GetAvailableActionsDto) => workflowEngineService.getAvailableActions(data),
+  });
+};