@ticketboothapp/booking 1.2.123 → 1.2.124

package/src/components/booking/useChangeBookingReceiptFloorController.ts

@@ -0,0 +1,449 @@
+import { useCallback, useMemo } from 'react';
+import { formatInTimeZone } from 'date-fns-tz';
+import type { Availability, ReturnOption } from '../../lib/booking-api';
+import type { ChangeFlowProtectedReceiptPricing } from '../../lib/booking/change-flow-pricing';
+import {
+  isParentProductId,
+  normalizeProductOptionIdForChangeFlow,
+} from '../../lib/booking/product-option-id';
+import type { ChangeBookingFlowProps } from './booking-flow-types';
+import type { Currency } from './CurrencySwitcher';
+import {
+  getAvailabilityOptionId,
+  normalizeLineLabelForCompare,
+  normalizeTicketCategoryFromReceiptLabel,
+  parseAvailabilityDateTime,
+} from './change-booking-flow-helpers';
+
+interface UseChangeBookingReceiptFloorControllerOptions {
+  productId: string;
+  initialValues?: ChangeBookingFlowProps['initialValues'];
+  originalReceipt: ChangeBookingFlowProps['originalReceipt'];
+  selectedDate: string | null;
+  selectedAvailability: Availability | null;
+  selectedReturnOption: ReturnOption | null;
+  companyTimezone: string;
+  changeFlowResolvedInitialProductOptionId: string | null;
+  applyReceiptPaidFloorsEnabled: boolean;
+  isCustomerSelfServeChange: boolean;
+  currency: Currency;
+  serverReturnOptionPriceByReturnAvailabilityId?: Record<string, number>;
+}
+
+export function useChangeBookingReceiptFloorController({
+  productId,
+  initialValues,
+  originalReceipt,
+  selectedDate,
+  selectedAvailability,
+  selectedReturnOption,
+  companyTimezone,
+  changeFlowResolvedInitialProductOptionId,
+  applyReceiptPaidFloorsEnabled,
+  isCustomerSelfServeChange,
+  currency,
+  serverReturnOptionPriceByReturnAvailabilityId,
+}: UseChangeBookingReceiptFloorControllerOptions) {
+  /**
+   * Parent catalog product id (`p_...`) for minimum-paid receipt floors: explicit parent on the booking,
+   * otherwise the product loaded for this change session (booking payload may only carry `po_...`).
+   */
+  const changeFlowBookingParentProductIdForFloors = useMemo(() => {
+    const pid = initialValues?.productId?.trim();
+    if (pid && isParentProductId(pid)) return pid;
+    return productId.trim();
+  }, [initialValues?.productId, productId]);
+
+  const changeFlowApplyReceiptPaidFloors = useMemo(
+    () => applyReceiptPaidFloorsEnabled && changeFlowBookingParentProductIdForFloors === productId.trim(),
+    [applyReceiptPaidFloorsEnabled, changeFlowBookingParentProductIdForFloors, productId],
+  );
+
+  const changeFlowInitialTicketQtyByCategory = useMemo(() => {
+    const qtyByCategory = new Map<string, number>();
+    if (!initialValues?.bookingItems?.length) return qtyByCategory;
+    for (const item of initialValues.bookingItems) {
+      const category = item.category?.trim().toUpperCase();
+      if (!category) continue;
+      qtyByCategory.set(category, Math.max(0, Number(item.count) || 0));
+    }
+    return qtyByCategory;
+  }, [initialValues?.bookingItems]);
+
+  const changeFlowInitialTicketCount = useMemo(() => {
+    let sum = 0;
+    for (const qty of changeFlowInitialTicketQtyByCategory.values()) sum += qty;
+    return sum;
+  }, [changeFlowInitialTicketQtyByCategory]);
+
+  const changeFlowSeatCreditForOutboundAvailability = useCallback(
+    (availability: Availability): number => {
+      if (changeFlowInitialTicketCount <= 0) return 0;
+      const initialAvailabilityId = initialValues?.availabilityId?.trim();
+      const availabilityId = availability.availabilityId?.trim();
+      if (initialAvailabilityId && availabilityId) {
+        return initialAvailabilityId === availabilityId ? changeFlowInitialTicketCount : 0;
+      }
+      if (!initialValues?.dateTime) return 0;
+      const selectedMs = parseAvailabilityDateTime(availability.dateTime).getTime();
+      const initialMs = parseAvailabilityDateTime(initialValues.dateTime).getTime();
+      if (selectedMs !== initialMs) return 0;
+      const selectedOpt = normalizeProductOptionIdForChangeFlow(availability.productOptionId);
+      const initialOpt = changeFlowResolvedInitialProductOptionId;
+      if (selectedOpt != null && initialOpt != null) {
+        return selectedOpt === initialOpt ? changeFlowInitialTicketCount : 0;
+      }
+      const legacyInitial = initialValues.productOptionId?.trim() || null;
+      const legacySelected = availability.productOptionId?.trim() || null;
+      if (!legacySelected || !legacyInitial) return changeFlowInitialTicketCount;
+      return legacySelected === legacyInitial ? changeFlowInitialTicketCount : 0;
+    },
+    [
+      changeFlowInitialTicketCount,
+      changeFlowResolvedInitialProductOptionId,
+      initialValues?.availabilityId,
+      initialValues?.dateTime,
+      initialValues?.productOptionId,
+    ],
+  );
+
+  const changeFlowSeatCreditForReturnAvailabilityId = useCallback(
+    (returnAvailabilityId: string | null | undefined): number => {
+      if (changeFlowInitialTicketCount <= 0) return 0;
+      const initialReturnAvailabilityId = initialValues?.returnAvailabilityId?.trim() || null;
+      const selectedReturnAvailabilityId = returnAvailabilityId?.trim() || null;
+      if (!selectedReturnAvailabilityId) {
+        return initialReturnAvailabilityId == null ? changeFlowInitialTicketCount : 0;
+      }
+      if (!initialReturnAvailabilityId) return 0;
+      return selectedReturnAvailabilityId === initialReturnAvailabilityId
+        ? changeFlowInitialTicketCount
+        : 0;
+    },
+    [changeFlowInitialTicketCount, initialValues?.returnAvailabilityId],
+  );
+
+  const getCalendarEffectiveOutboundVacancies = useCallback(
+    (avail: Availability) =>
+      Math.max(0, avail.vacancies ?? 0) + changeFlowSeatCreditForOutboundAvailability(avail),
+    [changeFlowSeatCreditForOutboundAvailability],
+  );
+
+  const changeFlowTicketBookedUnitPriceByCategory = useMemo(() => {
+    if (!originalReceipt?.lineItems?.length) return new Map<string, number>();
+    const amountByCategory = new Map<string, number>();
+    const qtyByCategory = new Map<string, number>();
+    for (const line of originalReceipt.lineItems) {
+      const type = (line.type || '').trim().toUpperCase();
+      if (type !== 'TICKET') continue;
+      const category = normalizeTicketCategoryFromReceiptLabel(line.label || '');
+      const amount = Number(line.amount ?? 0);
+      const qty = Number(line.quantity ?? 0);
+      if (!category || !Number.isFinite(amount) || !Number.isFinite(qty) || amount <= 0 || qty <= 0) continue;
+      amountByCategory.set(category, (amountByCategory.get(category) ?? 0) + amount);
+      qtyByCategory.set(category, (qtyByCategory.get(category) ?? 0) + qty);
+    }
+    const floors = new Map<string, number>();
+    for (const [category, qty] of qtyByCategory.entries()) {
+      const totalAmount = amountByCategory.get(category) ?? 0;
+      if (totalAmount > 0 && qty > 0) floors.set(category, totalAmount / qty);
+    }
+    return floors;
+  }, [originalReceipt?.lineItems]);
+
+  /**
+   * When the API omits `returnUnitFloorPerPerson`, derive per-person paid return from the stored receipt
+   * so catalog "free" return slots still show and price at the original return value in change flow.
+   */
+  const changeFlowReturnUnitFloorFromReceipt = useMemo(() => {
+    if (!originalReceipt?.lineItems?.length) return null;
+    let totalAmount = 0;
+    let totalQty = 0;
+    for (const line of originalReceipt.lineItems) {
+      const type = (line.type || '').trim().toUpperCase();
+      if (type !== 'RETURN_OPTION' && type !== 'RETURN') continue;
+      const amount = Number(line.amount ?? 0);
+      const qtyRaw = Number(line.quantity ?? 0);
+      const qty = qtyRaw > 0 ? qtyRaw : changeFlowInitialTicketCount;
+      if (!Number.isFinite(amount) || !Number.isFinite(qty) || amount <= 0 || qty <= 0) continue;
+      totalAmount += amount;
+      totalQty += qty;
+    }
+    if (totalAmount <= 0 || totalQty <= 0) return null;
+    return totalAmount / totalQty;
+  }, [originalReceipt?.lineItems, changeFlowInitialTicketCount]);
+
+  const effectiveChangeFlowReturnUnitFloorPerPerson = useMemo(() => {
+    const fromApi = Number(initialValues?.returnUnitFloorPerPerson ?? 0);
+    if (Number.isFinite(fromApi) && fromApi > 0) return fromApi;
+    const fromReceipt = changeFlowReturnUnitFloorFromReceipt;
+    if (fromReceipt != null && fromReceipt > 0) return fromReceipt;
+    return null;
+  }, [initialValues?.returnUnitFloorPerPerson, changeFlowReturnUnitFloorFromReceipt]);
+
+  const changeFlowBookedFeeUnitByNormalizedLabel = useMemo(() => {
+    const feeUnitByLabel = new Map<string, number>();
+    if (!originalReceipt?.lineItems?.length) return feeUnitByLabel;
+    for (const line of originalReceipt.lineItems) {
+      const type = (line.type || '').trim().toUpperCase();
+      if (!line.label || type === 'TICKET' || type === 'RETURN_OPTION' || type === 'TAX') continue;
+      if (type.includes('PROMO') || type.includes('VOUCHER') || type.includes('GIFT')) continue;
+      const amount = Number(line.amount ?? 0);
+      const qtyRaw = Number(line.quantity ?? 0);
+      const qty = qtyRaw > 0 ? qtyRaw : changeFlowInitialTicketCount;
+      if (!Number.isFinite(amount) || !Number.isFinite(qty) || amount <= 0 || qty <= 0) continue;
+      const key = normalizeLineLabelForCompare(line.label);
+      if (!key) continue;
+      feeUnitByLabel.set(key, amount / qty);
+    }
+    return feeUnitByLabel;
+  }, [originalReceipt?.lineItems, changeFlowInitialTicketCount]);
+
+  const changeFlowOutboundMatchesOriginalSelection = useMemo(() => {
+    if (!selectedAvailability || !initialValues?.dateTime) return false;
+    const initialAvailabilityId = initialValues.availabilityId?.trim();
+    const selectedAvailabilityId = selectedAvailability.availabilityId?.trim();
+    const idsMatch =
+      Boolean(initialAvailabilityId && selectedAvailabilityId) &&
+      initialAvailabilityId === selectedAvailabilityId;
+    if (idsMatch) return true;
+    const selectedMs = parseAvailabilityDateTime(selectedAvailability.dateTime).getTime();
+    const initialMs = parseAvailabilityDateTime(initialValues.dateTime).getTime();
+    if (selectedMs !== initialMs) return false;
+    const selectedOpt = normalizeProductOptionIdForChangeFlow(getAvailabilityOptionId(selectedAvailability));
+    const initialOpt = changeFlowResolvedInitialProductOptionId;
+    if (selectedOpt != null && initialOpt != null) {
+      return selectedOpt === initialOpt;
+    }
+    const legacyInitial = initialValues.productOptionId?.trim() || null;
+    const legacySelected = getAvailabilityOptionId(selectedAvailability) || null;
+    return !legacySelected || !legacyInitial || legacySelected === legacyInitial;
+  }, [
+    selectedAvailability,
+    initialValues?.availabilityId,
+    initialValues?.dateTime,
+    initialValues?.productOptionId,
+    changeFlowResolvedInitialProductOptionId,
+  ]);
+
+  /**
+   * Rule A (exact locked ticket/fee units): same calendar departure day and same product option as the booking.
+   * A different departure time on that day with the same PO still counts as unchanged.
+   */
+  const changeFlowTicketPricingUnchangedItinerary = useMemo(() => {
+    if (!selectedAvailability || !initialValues?.dateTime?.trim()) return false;
+    let initialDay: string;
+    try {
+      initialDay = formatInTimeZone(
+        parseAvailabilityDateTime(initialValues.dateTime.trim()),
+        companyTimezone,
+        'yyyy-MM-dd',
+      );
+    } catch {
+      return false;
+    }
+    if (!selectedDate || selectedDate !== initialDay) return false;
+    const selectedOpt = normalizeProductOptionIdForChangeFlow(getAvailabilityOptionId(selectedAvailability));
+    const initialOpt = changeFlowResolvedInitialProductOptionId;
+    if (selectedOpt != null && initialOpt != null) {
+      return selectedOpt === initialOpt;
+    }
+    const legacyInitial = initialValues.productOptionId?.trim() || null;
+    const legacySelected = getAvailabilityOptionId(selectedAvailability) || null;
+    return Boolean(legacySelected && legacyInitial && legacySelected === legacyInitial);
+  }, [
+    selectedDate,
+    selectedAvailability,
+    initialValues?.dateTime,
+    initialValues?.productOptionId,
+    companyTimezone,
+    changeFlowResolvedInitialProductOptionId,
+  ]);
+
+  const changeFlowProtectedReceiptPricing = useMemo((): ChangeFlowProtectedReceiptPricing => {
+    return changeFlowTicketPricingUnchangedItinerary ? 'exact_from_receipt' : 'max_with_catalog';
+  }, [changeFlowTicketPricingUnchangedItinerary]);
+
+  const changeFlowReturnMatchesOriginalSelection = useMemo(() => {
+    const initialReturnAvailabilityId = initialValues?.returnAvailabilityId?.trim() || null;
+    const selectedReturnAvailabilityId = selectedReturnOption?.returnAvailabilityId?.trim() || null;
+    const initialReturnDt = initialValues?.returnDateTime?.trim() || null;
+    const selectedReturnDt = selectedReturnOption?.dateTime?.trim() || null;
+
+    if (!selectedReturnAvailabilityId) {
+      return initialReturnAvailabilityId == null;
+    }
+    if (initialReturnAvailabilityId && selectedReturnAvailabilityId) {
+      if (initialReturnAvailabilityId === selectedReturnAvailabilityId) return true;
+      if (initialReturnDt && selectedReturnDt) {
+        return (
+          parseAvailabilityDateTime(initialReturnDt).getTime() ===
+          parseAvailabilityDateTime(selectedReturnDt).getTime()
+        );
+      }
+      return false;
+    }
+    if (!initialReturnAvailabilityId && initialReturnDt && selectedReturnDt) {
+      return (
+        parseAvailabilityDateTime(initialReturnDt).getTime() ===
+        parseAvailabilityDateTime(selectedReturnDt).getTime()
+      );
+    }
+    return false;
+  }, [
+    initialValues?.returnAvailabilityId,
+    initialValues?.returnDateTime,
+    selectedReturnOption?.returnAvailabilityId,
+    selectedReturnOption?.dateTime,
+  ]);
+
+  /**
+   * Mirrors BE `returnPricingRuleA`: receipt floor exists, outbound itinerary is unchanged, and the selected return id
+   * exactly equals the booking return id.
+   */
+  const changeFlowReturnPricingRuleA = useMemo(() => {
+    if (!changeFlowApplyReceiptPaidFloors) return false;
+    if (effectiveChangeFlowReturnUnitFloorPerPerson == null) return false;
+    if (!changeFlowTicketPricingUnchangedItinerary) return false;
+    const booked = initialValues?.returnAvailabilityId?.trim() || null;
+    const selected = selectedReturnOption?.returnAvailabilityId?.trim() || null;
+    return Boolean(booked && selected && booked === selected);
+  }, [
+    changeFlowApplyReceiptPaidFloors,
+    effectiveChangeFlowReturnUnitFloorPerPerson,
+    changeFlowTicketPricingUnchangedItinerary,
+    initialValues?.returnAvailabilityId,
+    selectedReturnOption?.returnAvailabilityId,
+  ]);
+
+  const returnOptionsWithFloor = useMemo(() => {
+    const options = selectedAvailability?.returnOptions ?? [];
+    const floor = effectiveChangeFlowReturnUnitFloorPerPerson;
+    const applyReturnFloor = floor != null && isCustomerSelfServeChange;
+    return options.map((opt) => {
+      const vacancyCredit = changeFlowSeatCreditForReturnAvailabilityId(opt.returnAvailabilityId);
+      const adjustedVacancies = Math.max(0, opt.vacancies ?? 0) + vacancyCredit;
+      const rawPerPerson = opt.priceAdjustmentByCurrency?.[currency] ?? 0;
+      const flooredPerPerson = applyReturnFloor ? Math.max(rawPerPerson, floor) : rawPerPerson;
+      let perPerson = flooredPerPerson;
+      if (isCustomerSelfServeChange && serverReturnOptionPriceByReturnAvailabilityId && opt.returnAvailabilityId) {
+        const sid = opt.returnAvailabilityId.trim();
+        const sp = serverReturnOptionPriceByReturnAvailabilityId[sid];
+        if (sp != null && Number.isFinite(sp)) {
+          perPerson = sp;
+        }
+      }
+      if (applyReturnFloor && floor != null) {
+        perPerson = Math.max(perPerson, floor);
+      }
+      if (perPerson === rawPerPerson && adjustedVacancies === (opt.vacancies ?? 0)) return opt;
+      return {
+        ...opt,
+        vacancies: adjustedVacancies,
+        priceAdjustmentByCurrency: {
+          ...(opt.priceAdjustmentByCurrency ?? {}),
+          [currency]: perPerson,
+        },
+      };
+    });
+  }, [
+    selectedAvailability?.returnOptions,
+    effectiveChangeFlowReturnUnitFloorPerPerson,
+    isCustomerSelfServeChange,
+    currency,
+    changeFlowSeatCreditForReturnAvailabilityId,
+    serverReturnOptionPriceByReturnAvailabilityId,
+  ]);
+
+  const selectedReturnOptionWithFloor = useMemo(() => {
+    if (!selectedReturnOption) return selectedReturnOption;
+    const floor = effectiveChangeFlowReturnUnitFloorPerPerson;
+    const applyReturnFloor = floor != null && isCustomerSelfServeChange;
+    const rawPerPerson = selectedReturnOption.priceAdjustmentByCurrency?.[currency] ?? 0;
+    let perPerson = rawPerPerson;
+    if (
+      isCustomerSelfServeChange &&
+      serverReturnOptionPriceByReturnAvailabilityId &&
+      selectedReturnOption.returnAvailabilityId
+    ) {
+      const sid = selectedReturnOption.returnAvailabilityId.trim();
+      const sp = serverReturnOptionPriceByReturnAvailabilityId[sid];
+      if (sp != null && Number.isFinite(sp)) {
+        perPerson = sp;
+      }
+    }
+    if (applyReturnFloor && floor != null) {
+      perPerson = Math.max(perPerson, floor);
+    }
+    if (perPerson === rawPerPerson) return selectedReturnOption;
+    return {
+      ...selectedReturnOption,
+      priceAdjustmentByCurrency: {
+        ...(selectedReturnOption.priceAdjustmentByCurrency ?? {}),
+        [currency]: perPerson,
+      },
+    };
+  }, [
+    selectedReturnOption,
+    effectiveChangeFlowReturnUnitFloorPerPerson,
+    isCustomerSelfServeChange,
+    currency,
+    serverReturnOptionPriceByReturnAvailabilityId,
+  ]);
+
+  const effectiveSelectedPickupVacancies = useMemo(() => {
+    if (!selectedAvailability) return 0;
+    const seatCredit = changeFlowSeatCreditForOutboundAvailability(selectedAvailability);
+    return Math.max(0, selectedAvailability.vacancies ?? 0) + seatCredit;
+  }, [selectedAvailability, changeFlowSeatCreditForOutboundAvailability]);
+
+  const effectiveSelectedReturnVacancies = useMemo(() => {
+    if (!selectedReturnOption) return null;
+    const seatCredit = changeFlowSeatCreditForReturnAvailabilityId(
+      selectedReturnOption.returnAvailabilityId
+    );
+    return Math.max(0, selectedReturnOption.vacancies ?? 0) + seatCredit;
+  }, [selectedReturnOption, changeFlowSeatCreditForReturnAvailabilityId]);
+
+  /** Round-trip party limit: both legs must fit, using the tighter of outbound vs return vacancies. */
+  const effectivePartySizeCap = useMemo(() => {
+    if (!selectedAvailability) return 0;
+    const outboundSeatCredit =
+      changeFlowOutboundMatchesOriginalSelection && changeFlowInitialTicketCount > 0
+        ? changeFlowInitialTicketCount
+        : 0;
+    const outbound = Math.max(0, selectedAvailability.vacancies ?? 0) + outboundSeatCredit;
+    if (selectedReturnOption == null) return outbound;
+    const returnSeatCredit =
+      changeFlowReturnMatchesOriginalSelection && changeFlowInitialTicketCount > 0
+        ? changeFlowInitialTicketCount
+        : 0;
+    const returnCap = Math.max(0, selectedReturnOption.vacancies ?? 0) + returnSeatCredit;
+    return Math.min(outbound, returnCap);
+  }, [
+    selectedAvailability,
+    selectedReturnOption,
+    changeFlowInitialTicketCount,
+    changeFlowOutboundMatchesOriginalSelection,
+    changeFlowReturnMatchesOriginalSelection,
+  ]);
+
+  return {
+    changeFlowApplyReceiptPaidFloors,
+    changeFlowSeatCreditForOutboundAvailability,
+    changeFlowTicketBookedUnitPriceByCategory,
+    effectiveChangeFlowReturnUnitFloorPerPerson,
+    changeFlowBookedFeeUnitByNormalizedLabel,
+    changeFlowInitialTicketQtyByCategory,
+    changeFlowInitialTicketCount,
+    changeFlowProtectedReceiptPricing,
+    changeFlowReturnPricingRuleA,
+    returnOptionsWithFloor,
+    selectedReturnOptionWithFloor,
+    returnOptionForOrderSummary: selectedReturnOptionWithFloor,
+    effectiveSelectedPickupVacancies,
+    effectiveSelectedReturnVacancies,
+    effectivePartySizeCap,
+    getCalendarEffectiveOutboundVacancies,
+  };
+}