contrat,booking,global logestic

apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts

@@ -0,0 +1,225 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import toast from "react-hot-toast";
+import type { QueryClient } from "@tanstack/react-query";
+import type { Freight } from "@edr/types";
+
+import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
+import {
+  contractsService,
+  type ContractListFilter,
+  type SignContractPayload,
+} from "@/services/contracts.service";
+
+function invalidateContractDetail(qc: QueryClient, id: string): Promise<void> {
+  return Promise.all([
+    qc.invalidateQueries({ queryKey: QUERY_KEYS.CONTRACTS.byId(id) }),
+    qc.invalidateQueries({ queryKey: QUERY_KEYS.CONTRACTS.ROOT }),
+  ]).then(() => undefined);
+}
+
+export function useContractList(filter?: ContractListFilter, enabled = true) {
+  return useQuery({
+    queryKey: QUERY_KEYS.CONTRACTS.list(filter),
+    queryFn: () => contractsService.list(filter),
+    enabled,
+  });
+}
+
+export function useContractListSummary(
+  filter?: ContractListFilter,
+  enabled = true,
+) {
+  return useQuery({
+    queryKey: QUERY_KEYS.CONTRACTS.listSummary(filter),
+    queryFn: () => contractsService.getListSummary(filter),
+    enabled,
+  });
+}
+
+export function useContractDetail(id: string | undefined) {
+  return useQuery({
+    queryKey: QUERY_KEYS.CONTRACTS.byId(id ?? ""),
+    queryFn: () => contractsService.getById(id!),
+    enabled: Boolean(id),
+  });
+}
+
+export function useContractClearanceQueue(region = "ET", enabled = true) {
+  return useQuery({
+    queryKey: QUERY_KEYS.CONTRACTS.clearanceQueue(region),
+    queryFn: () => contractsService.getClearanceQueue(region),
+    enabled,
+  });
+}
+
+export function useContractMilestones(id: string | undefined) {
+  return useQuery({
+    queryKey: QUERY_KEYS.CONTRACTS.milestones(id ?? ""),
+    queryFn: () => contractsService.listMilestonesForContract(id!),
+    enabled: Boolean(id),
+  });
+}
+
+export function useBookingMilestones(bookingId: string | undefined) {
+  return useQuery({
+    queryKey: QUERY_KEYS.CONTRACTS.bookingMilestones(bookingId ?? ""),
+    queryFn: () => contractsService.listMilestonesForBooking(bookingId!),
+    enabled: Boolean(bookingId),
+  });
+}
+
+export function useContractMutations(contractId: string) {
+  const qc = useQueryClient();
+  const onSuccess = (data: { id: string }, message: string) => {
+    toast.success(message);
+    void invalidateContractDetail(qc, data.id);
+  };
+
+  const staffAccept = useMutation({
+    mutationFn: (validityDays: number) =>
+      contractsService.staffAccept(contractId, validityDays),
+    onSuccess: (data) => onSuccess(data, "Contract accepted for approval"),
+    onError: () => toast.error("Failed to accept contract"),
+  });
+
+  const requestChanges = useMutation({
+    mutationFn: (note: string) =>
+      contractsService.requestChanges(contractId, note),
+    onSuccess: (data) => onSuccess(data, "Changes requested from customer"),
+    onError: () => toast.error("Failed to request changes"),
+  });
+
+  const reject = useMutation({
+    mutationFn: (reason: string) => contractsService.reject(contractId, reason),
+    onSuccess: (data) => onSuccess(data, "Contract rejected"),
+    onError: () => toast.error("Failed to reject contract"),
+  });
+
+  const approveStep = useMutation({
+    mutationFn: ({
+      stepId,
+      requiredRole,
+    }: {
+      stepId: string;
+      requiredRole: string;
+    }) =>
+      contractsService.approveStep({ id: contractId, stepId, requiredRole }),
+    onSuccess: (data) => onSuccess(data, "Approval step completed"),
+    onError: () => toast.error("Failed to approve step"),
+  });
+
+  const generateContract = useMutation({
+    mutationFn: () => contractsService.generateContract(contractId),
+    onSuccess: (data) => onSuccess(data, "Contract generated"),
+    onError: () => toast.error("Failed to generate contract"),
+  });
+
+  const signContract = useMutation({
+    mutationFn: (payload: SignContractPayload) =>
+      contractsService.signContract(contractId, payload),
+    onSuccess: (data) => onSuccess(data, "Contract signed"),
+    onError: () => toast.error("Failed to sign contract"),
+  });
+
+  const createBooking = useMutation({
+    mutationFn: (payload: Freight.CreateBookingUnderContractDto) =>
+      contractsService.createBookingUnderContract(contractId, payload),
+    onSuccess: () => {
+      toast.success("Booking created under contract");
+      void invalidateContractDetail(qc, contractId);
+    },
+    onError: () => toast.error("Failed to create booking"),
+  });
+
+  const isPending =
+    staffAccept.isPending ||
+    requestChanges.isPending ||
+    reject.isPending ||
+    approveStep.isPending ||
+    generateContract.isPending ||
+    signContract.isPending ||
+    createBooking.isPending;
+
+  return {
+    staffAccept,
+    requestChanges,
+    reject,
+    approveStep,
+    generateContract,
+    signContract,
+    createBooking,
+    isPending,
+  };
+}
+
+/** Pre-booking clearance mutations (GL ET) keyed on a contract. */
+export function useContractClearanceMutations(contractId: string) {
+  const qc = useQueryClient();
+
+  const refresh = () => {
+    void qc.invalidateQueries({
+      queryKey: QUERY_KEYS.CONTRACTS.clearance(contractId),
+    });
+    void qc.invalidateQueries({
+      queryKey: ["contracts", "clearance-queue"],
+    });
+    void invalidateContractDetail(qc, contractId);
+  };
+
+  const reviewDocument = useMutation({
+    mutationFn: (p: {
+      fileKey: string;
+      status: "APPROVED" | "QUERIED";
+      note?: string;
+    }) => contractsService.reviewClearanceDocument(contractId, p),
+    onSuccess: (_d, p) => {
+      toast.success(
+        p.status === "APPROVED"
+          ? "Document approved"
+          : "Query sent to customer",
+      );
+      refresh();
+    },
+    onError: () => toast.error("Could not update document"),
+  });
+
+  const uploadOutputDocuments = useMutation({
+    mutationFn: (files: Record<string, File | null>) =>
+      contractsService.uploadClearanceOutput(contractId, files),
+    onSuccess: () => {
+      toast.success("Output documents uploaded");
+      refresh();
+    },
+    onError: () => toast.error("Upload failed"),
+  });
+
+  const finalizeClearance = useMutation({
+    mutationFn: () => contractsService.finalizeClearance(contractId),
+    onSuccess: () => {
+      toast.success("Clearance finalized — ready for booking");
+      refresh();
+    },
+    onError: (e) =>
+      toast.error(
+        e instanceof Error ? e.message : "Could not finalize clearance",
+      ),
+  });
+
+  return { reviewDocument, uploadOutputDocuments, finalizeClearance };
+}
+
+/** Complete a post-booking GL milestone. */
+export function useCompleteMilestone(bookingId: string) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ code, note }: { code: string; note?: string }) =>
+      contractsService.completeMilestone(bookingId, code, note),
+    onSuccess: () => {
+      toast.success("Milestone completed");
+      void qc.invalidateQueries({
+        queryKey: QUERY_KEYS.CONTRACTS.bookingMilestones(bookingId),
+      });
+    },
+    onError: () => toast.error("Failed to complete milestone"),
+  });
+}