@qite/tide-booking-component/src/booking-wizard/use-offer-printer.ts

React Booking wizard & Booking product component for Tide

import { useCallback, useContext, useState } from "react";
import SettingsContext from "./settings-context";
import { buildTideClientConfig } from "../shared/utils/tide-api-utils";
import { book, print } from "@qite/tide-client";

import type {
  BookingPackage,
  BookingPackageBookRequest,
  BookingPackageDossier,
  BookingPackageRequest,
  AgentPrintActionRequest,
  Pax,
  BookingPackagePax,
} from "@qite/tide-client/build/types";

export interface UseOfferPrinterArgs {
  bookingPackage?: BookingPackage;
  getPax: () => Pax[] | undefined;
  tagIds?: number[];
  printActionId?: number | null;
  onPrinted?: (pdfUrl: string) => void;
}

export function useOfferPrinter({
  bookingPackage,
  getPax,
  tagIds = [],
  printActionId = null,
  onPrinted,
}: UseOfferPrinterArgs) {
  const settings = useContext(SettingsContext);
  if (!settings)
    throw new Error("useOfferPrinter must be used inside <BookingWizard>");

  const { language, officeId } = settings;
  const agentId = (settings as any).agentAdressId;

  if (typeof agentId !== "number" || agentId <= 0) {
    throw new Error("Missing agentAdressId in wizard settings");
  }

  const [stage, setStage] = useState<"idle" | "creating" | "printing">("idle");
  const loading = stage !== "idle";

  const createOffer = useCallback(async (): Promise<BookingPackageDossier> => {
    const paxRaw = getPax();
    if (!bookingPackage || !paxRaw?.length) {
      throw new Error("Missing booking package or pax");
    }

    const pax = paxRaw as unknown as BookingPackagePax[];

    const request: BookingPackageRequest<BookingPackageBookRequest> = {
      officeId,
      agentId,
      payload: {
        package: bookingPackage,
        status: 0,
        pax,
        nonTravelPax: [],
        notifications: [],
        tagIds,
        customerRequests: [],
      },
    };

    const cfg = buildTideClientConfig();
    return book(cfg, request, undefined, language);
  }, [agentId, bookingPackage, getPax, language, officeId, tagIds]);

  const languageData = [
    { code: "nl-BE", tideId: 1 },
    { code: "fr-BE", tideId: 2 },
    { code: "en-GB", tideId: 3 },
  ];

  function getTideLanguageId(code: string) {
    return languageData.find((l) => l.code === code)?.tideId || 1;
  }

  const printOffer = useCallback(
    async (offer: BookingPackageDossier) => {
      const cfg = buildTideClientConfig();

      const req: AgentPrintActionRequest = {
        id: printActionId ?? 0,
        dossierNumber: (offer as any).dossierNumber ?? (offer as any).number,
        languageId: getTideLanguageId(language),
      };

      const res = await print(cfg, req);
      const buf = await res.arrayBuffer();
      const url = URL.createObjectURL(
        new Blob([buf], { type: "application/pdf" })
      );
      onPrinted?.(url);
      window.open(url);
    },
    [language, onPrinted]
  );

  const handlePrint = useCallback(async () => {
    try {
      setStage("creating");
      const offer = await createOffer();
      setStage("printing");
      await printOffer(offer);
    } catch (err) {
      console.error("Offer print failed:", err);
      throw err;
    } finally {
      setStage("idle");
    }
  }, [createOffer, printOffer]);

  return { handlePrint, loading, stage };
}