@ticketboothapp/booking 1.2.122 → 1.2.124

package/src/components/booking/usePrivateShuttlePromoController.ts

@@ -0,0 +1,143 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import {
+  validatePromoCode,
+  type Availability,
+} from '../../lib/booking-api';
+
+type TranslationFn = (key: string) => string;
+
+export interface UsePrivateShuttlePromoControllerParams {
+  initialPromoCode?: string | null;
+  isAdmin: boolean;
+  selectedAvailability: Availability | null;
+  selectedOption: string;
+  selectedStartTime: string;
+  resourceCount: number;
+  productCompanyId?: string | null;
+  productId: string;
+  onPromoChangesAvailability: () => void;
+  t: TranslationFn;
+}
+
+export function usePrivateShuttlePromoController({
+  initialPromoCode,
+  isAdmin,
+  selectedAvailability,
+  selectedOption,
+  selectedStartTime,
+  resourceCount,
+  productCompanyId,
+  productId,
+  onPromoChangesAvailability,
+  t,
+}: UsePrivateShuttlePromoControllerParams) {
+  const [promoCodeInput, setPromoCodeInput] = useState(() => initialPromoCode?.trim() ?? '');
+  const [appliedPromoCode, setAppliedPromoCode] = useState<string | null>(
+    () => initialPromoCode?.trim() || null,
+  );
+  const [promoCodeError, setPromoCodeError] = useState('');
+  const [promoCodeValidating, setPromoCodeValidating] = useState(false);
+  const lastValidatedInputRef = useRef<string | null>(null);
+
+  const activePromoCode = isAdmin ? appliedPromoCode : null;
+  const hasOngoingDiscount = useMemo(
+    () =>
+      selectedAvailability?.rates?.some((rate) =>
+        (rate.appliedAdjustments ?? rate.applied_adjustments ?? []).some(
+          (adjustment) => (adjustment.type ?? '').toLowerCase() === 'deal',
+        ),
+      ) ?? false,
+    [selectedAvailability],
+  );
+
+  const handleApplyPromo = useCallback(async () => {
+    const code = promoCodeInput.trim().toUpperCase();
+    if (!isAdmin) return;
+    if (!code || appliedPromoCode === code) return;
+    if (!productCompanyId) return;
+    lastValidatedInputRef.current = code;
+    setPromoCodeError('');
+    setPromoCodeValidating(true);
+    try {
+      const result = await validatePromoCode(
+        code,
+        productCompanyId,
+        productId,
+        hasOngoingDiscount,
+      );
+      if (result.valid) {
+        setAppliedPromoCode(code);
+        onPromoChangesAvailability();
+      } else {
+        setPromoCodeError(
+          result.error === 'Promo codes cannot be stacked with deals'
+            ? (t('booking.promoCodesCannotStackWithDiscounts') || result.error)
+            : (result.error || t('booking.invalidPromoCode') || 'Invalid or expired promo code'),
+        );
+      }
+    } catch (err) {
+      setPromoCodeError(err instanceof Error ? err.message : 'Failed to validate promo code');
+    } finally {
+      setPromoCodeValidating(false);
+    }
+  }, [
+    promoCodeInput,
+    appliedPromoCode,
+    isAdmin,
+    productCompanyId,
+    productId,
+    hasOngoingDiscount,
+    t,
+    onPromoChangesAvailability,
+  ]);
+
+  const handleApplyPromoRef = useRef(handleApplyPromo);
+  handleApplyPromoRef.current = handleApplyPromo;
+
+  const handlePromoInputChange = useCallback((value: string) => {
+    setPromoCodeInput(value);
+    setPromoCodeError('');
+  }, []);
+
+  const handleRemovePromo = useCallback(() => {
+    lastValidatedInputRef.current = null;
+    setAppliedPromoCode(null);
+    setPromoCodeInput('');
+    setPromoCodeError('');
+    onPromoChangesAvailability();
+  }, [onPromoChangesAvailability]);
+
+  useEffect(() => {
+    if (!isAdmin) return;
+    const trimmed = promoCodeInput.trim().toUpperCase();
+    if (!trimmed) return;
+    if (!selectedOption || !selectedStartTime || resourceCount === 0) return;
+    if (appliedPromoCode === trimmed) return;
+    if (lastValidatedInputRef.current === trimmed && promoCodeError) return;
+
+    const timer = setTimeout(() => {
+      handleApplyPromoRef.current();
+    }, 600);
+
+    return () => clearTimeout(timer);
+  }, [
+    isAdmin,
+    promoCodeInput,
+    appliedPromoCode,
+    promoCodeError,
+    selectedOption,
+    selectedStartTime,
+    resourceCount,
+  ]);
+
+  return {
+    promoCodeInput,
+    appliedPromoCode,
+    activePromoCode,
+    promoCodeError,
+    promoCodeValidating,
+    handlePromoInputChange,
+    handleApplyPromo,
+    handleRemovePromo,
+  };
+}

package/src/components/booking/usePrivateShuttlePromoDiscount.ts

@@ -0,0 +1,124 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { getPromoDiscount } from '../../lib/booking-api';
+import type { Currency } from './CurrencySwitcher';
+
+interface UsePrivateShuttlePromoDiscountParams {
+  activePromoCode: string | null;
+  selectedOption: string;
+  selectedDate: string;
+  selectedStartTime: string;
+  resourceCount: number;
+  productCompanyId?: string | null;
+  productId: string;
+  currency: Currency;
+  subtotal: number;
+}
+
+export function usePrivateShuttlePromoDiscount({
+  activePromoCode,
+  selectedOption,
+  selectedDate,
+  selectedStartTime,
+  resourceCount,
+  productCompanyId,
+  productId,
+  currency,
+  subtotal,
+}: UsePrivateShuttlePromoDiscountParams) {
+  const [promoDiscountAmount, setPromoDiscountAmount] = useState(0);
+  const [isGiftCard, setIsGiftCard] = useState(false);
+  const [isVoucher, setIsVoucher] = useState(false);
+
+  const resetPromoDiscount = useCallback(() => {
+    setPromoDiscountAmount(0);
+    setIsGiftCard(false);
+    setIsVoucher(false);
+  }, []);
+
+  const promoDiscountFetchKey = useMemo(() => {
+    if (
+      !activePromoCode ||
+      !selectedOption ||
+      !selectedDate ||
+      !selectedStartTime ||
+      resourceCount === 0
+    ) {
+      return '';
+    }
+    if (!productCompanyId) return '';
+    return [
+      activePromoCode,
+      productCompanyId,
+      productId,
+      selectedOption,
+      selectedDate,
+      selectedStartTime,
+      currency,
+      resourceCount,
+      Math.round(subtotal * 100),
+    ].join('::');
+  }, [
+    activePromoCode,
+    selectedOption,
+    selectedDate,
+    selectedStartTime,
+    resourceCount,
+    productCompanyId,
+    productId,
+    currency,
+    subtotal,
+  ]);
+
+  useEffect(() => {
+    if (!promoDiscountFetchKey) {
+      resetPromoDiscount();
+      return;
+    }
+
+    let cancelled = false;
+    getPromoDiscount(
+      activePromoCode!,
+      productCompanyId!,
+      productId,
+      selectedOption,
+      currency,
+      [{ category: 'RESOURCE', qty: resourceCount }],
+      selectedDate,
+      subtotal,
+    )
+      .then((res) => {
+        if (cancelled) return;
+        setPromoDiscountAmount(res.discount ?? 0);
+        setIsGiftCard(res.isGiftCard ?? false);
+        setIsVoucher(res.isVoucher ?? false);
+      })
+      .catch(() => {
+        if (cancelled) return;
+        resetPromoDiscount();
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    promoDiscountFetchKey,
+    activePromoCode,
+    productCompanyId,
+    productId,
+    selectedOption,
+    currency,
+    resourceCount,
+    selectedDate,
+    subtotal,
+    resetPromoDiscount,
+  ]);
+
+  const effectivePromoDiscountAmount = promoDiscountAmount > 0 ? promoDiscountAmount : 0;
+
+  return {
+    promoDiscountAmount,
+    isGiftCard,
+    isVoucher,
+    effectivePromoDiscountAmount,
+    resetPromoDiscount,
+  };
+}

package/src/components/booking/useSeedPromoCodeInput.ts

@@ -0,0 +1,13 @@
+import { useEffect, type Dispatch, type SetStateAction } from 'react';
+
+export function useSeedPromoCodeInput(
+  autoAppliedPromoCode: string | undefined,
+  setPromoCodeInput: Dispatch<SetStateAction<string>>,
+) {
+  useEffect(() => {
+    if (!autoAppliedPromoCode) return;
+    const normalizedPromo = autoAppliedPromoCode.trim().toUpperCase();
+    if (!normalizedPromo) return;
+    setPromoCodeInput((current) => current || normalizedPromo);
+  }, [autoAppliedPromoCode, setPromoCodeInput]);
+}

package/src/components/booking/useStandardBookingAutoSelections.ts

@@ -0,0 +1,224 @@
+import { useEffect, useRef, type RefObject } from 'react';
+import { parseISO } from 'date-fns';
+import type { Availability, Product, ReturnOption } from '../../lib/booking-api';
+import {
+  availabilityMatchesSelectedDate,
+  parseAvailabilityDateTime,
+  pickDefaultAvailabilityForTimes,
+} from './standard-booking-availability';
+
+interface UseStandardBookingAutoSelectionsParams {
+  selectedDate: string;
+  selectedAvailability: Availability | null;
+  selectedReturnOption: ReturnOption | null;
+  timesForSelectedDateLength: number;
+  timesForSelectedDateSelectionKey: string;
+  activeOptions: Product['options'];
+  companyTimezone: string;
+  getPickupCutoffEligibleTimesForDate: (date: string) => Availability[];
+  setSelectedAvailability: (availability: Availability | null) => void;
+  setSelectedReturnOption: (option: ReturnOption | null) => void;
+  setSelectedDate: (date: string) => void;
+  setError: (error: string) => void;
+  initialReturnAvailabilityId?: string | null;
+  initialReturnDateTime?: string | null;
+  autoSelectFirstAvailableDate?: boolean;
+  isPartialLaunch: boolean;
+  initialDateTime?: string | null;
+  dates: string[];
+  isAdmin: boolean;
+  suppressCalendarDateScroll?: boolean;
+  contentRef?: RefObject<HTMLDivElement | null>;
+  useWindowScroll: boolean;
+  autoSelectFirstHighlightedPickup?: boolean;
+  highlightedPickupLocationIds?: string[];
+  pickupLocationId: string | null;
+  pickupLocationSkipped: boolean;
+  initialPickupLocationId?: string | null;
+  pickupLocations?: Product['pickupLocations'];
+  setPickupLocationId: (locationId: string | null) => void;
+  setPickupLocationSkipped: (skipped: boolean) => void;
+}
+
+function scrollAfterCalendarSelection(
+  contentRef: RefObject<HTMLDivElement | null> | undefined,
+  useWindowScroll: boolean,
+) {
+  setTimeout(() => {
+    const container = contentRef?.current;
+    if (!useWindowScroll && container && container.scrollHeight > container.clientHeight + 16) {
+      container.scrollBy({ top: 400, behavior: 'smooth' });
+    } else if (typeof window !== 'undefined') {
+      window.scrollBy({ top: 400, behavior: 'smooth' });
+    }
+  }, 100);
+}
+
+export function useStandardBookingAutoSelections({
+  selectedDate,
+  selectedAvailability,
+  selectedReturnOption,
+  timesForSelectedDateLength,
+  timesForSelectedDateSelectionKey,
+  activeOptions,
+  companyTimezone,
+  getPickupCutoffEligibleTimesForDate,
+  setSelectedAvailability,
+  setSelectedReturnOption,
+  setSelectedDate,
+  setError,
+  initialReturnAvailabilityId,
+  initialReturnDateTime,
+  autoSelectFirstAvailableDate = false,
+  isPartialLaunch,
+  initialDateTime,
+  dates,
+  isAdmin,
+  suppressCalendarDateScroll,
+  contentRef,
+  useWindowScroll,
+  autoSelectFirstHighlightedPickup = false,
+  highlightedPickupLocationIds,
+  pickupLocationId,
+  pickupLocationSkipped,
+  initialPickupLocationId,
+  pickupLocations,
+  setPickupLocationId,
+  setPickupLocationSkipped,
+}: UseStandardBookingAutoSelectionsParams) {
+  const hasAutoSelectedPartnerDateRef = useRef(false);
+  const hasAutoSelectedPartnerPickupRef = useRef(false);
+
+  useEffect(() => {
+    if (!selectedDate || timesForSelectedDateLength === 0) return;
+    if (
+      selectedAvailability &&
+      availabilityMatchesSelectedDate(selectedAvailability, selectedDate, companyTimezone)
+    ) {
+      return;
+    }
+    const toSelect = pickDefaultAvailabilityForTimes(
+      getPickupCutoffEligibleTimesForDate(selectedDate),
+      activeOptions,
+    );
+    if (toSelect) {
+      setSelectedAvailability(toSelect);
+      setError('');
+    }
+  }, [
+    selectedDate,
+    timesForSelectedDateLength,
+    timesForSelectedDateSelectionKey,
+    activeOptions,
+    selectedAvailability,
+    companyTimezone,
+    getPickupCutoffEligibleTimesForDate,
+    setSelectedAvailability,
+    setError,
+  ]);
+
+  useEffect(() => {
+    if (!selectedAvailability?.returnOptions?.length || selectedReturnOption) return;
+
+    const sorted = [...selectedAvailability.returnOptions].sort(
+      (a, b) => parseISO(a.dateTime).getTime() - parseISO(b.dateTime).getTime(),
+    );
+    const initialReturnIdForSelect = initialReturnAvailabilityId?.trim();
+    const initialReturnDtForSelect = initialReturnDateTime?.trim();
+    const preferBooked = initialReturnIdForSelect
+      ? sorted.find((option) => option.returnAvailabilityId === initialReturnIdForSelect)
+      : undefined;
+    const preferByDateTime =
+      initialReturnDtForSelect && !preferBooked
+        ? sorted.find((option) => {
+            try {
+              return (
+                parseAvailabilityDateTime(option.dateTime).getTime() ===
+                parseAvailabilityDateTime(initialReturnDtForSelect).getTime()
+              );
+            } catch {
+              return false;
+            }
+          })
+        : undefined;
+    const firstAvailable = sorted.find((option) => option.vacancies > 0);
+    const toSelect = preferBooked ?? preferByDateTime ?? firstAvailable;
+    if (toSelect) {
+      setSelectedReturnOption(toSelect);
+    }
+  }, [
+    selectedAvailability,
+    selectedReturnOption,
+    initialReturnAvailabilityId,
+    initialReturnDateTime,
+    setSelectedReturnOption,
+  ]);
+
+  useEffect(() => {
+    if (!autoSelectFirstAvailableDate) return;
+    if (isPartialLaunch) return;
+    if (initialDateTime?.trim()) return;
+    if (selectedDate !== '') return;
+    if (dates.length === 0) return;
+    if (hasAutoSelectedPartnerDateRef.current) return;
+
+    const firstWithInventory = dates.find((date) =>
+      getPickupCutoffEligibleTimesForDate(date).some((availability) => (availability.vacancies ?? 0) > 0),
+    );
+    const first = firstWithInventory ?? (isAdmin && dates[0] ? dates[0] : undefined);
+    if (!first) return;
+
+    hasAutoSelectedPartnerDateRef.current = true;
+    setSelectedDate(first);
+    setSelectedReturnOption(null);
+    setSelectedAvailability(
+      pickDefaultAvailabilityForTimes(getPickupCutoffEligibleTimesForDate(first), activeOptions),
+    );
+    if (!suppressCalendarDateScroll) {
+      scrollAfterCalendarSelection(contentRef, useWindowScroll);
+    }
+  }, [
+    autoSelectFirstAvailableDate,
+    isPartialLaunch,
+    initialDateTime,
+    selectedDate,
+    dates,
+    getPickupCutoffEligibleTimesForDate,
+    isAdmin,
+    activeOptions,
+    setSelectedAvailability,
+    setSelectedDate,
+    setSelectedReturnOption,
+    suppressCalendarDateScroll,
+    contentRef,
+    useWindowScroll,
+  ]);
+
+  useEffect(() => {
+    if (!autoSelectFirstHighlightedPickup) return;
+    if (hasAutoSelectedPartnerPickupRef.current) return;
+    if (!highlightedPickupLocationIds?.length) return;
+    if (pickupLocationId) return;
+    if (pickupLocationSkipped) return;
+    if (initialPickupLocationId?.trim()) return;
+    if (!pickupLocations?.length) return;
+
+    const match = highlightedPickupLocationIds.find((id) =>
+      pickupLocations.some((location) => location.id === id),
+    );
+    if (!match) return;
+
+    hasAutoSelectedPartnerPickupRef.current = true;
+    setPickupLocationId(match);
+    setPickupLocationSkipped(false);
+  }, [
+    autoSelectFirstHighlightedPickup,
+    highlightedPickupLocationIds,
+    pickupLocationId,
+    pickupLocationSkipped,
+    initialPickupLocationId,
+    pickupLocations,
+    setPickupLocationId,
+    setPickupLocationSkipped,
+  ]);
+}