@ticketboothapp/booking 1.2.123 → 1.2.125

package/src/components/booking/standard-booking-payment-choice-runner.ts

@@ -0,0 +1,274 @@
+import {
+  confirmBookingWithoutPayment,
+  type CheckoutBreakdown,
+  type ItineraryDisplayStep,
+} from '../../lib/booking-api';
+import type { OrderSummary } from '../../lib/booking/pricing';
+import {
+  buildBookingSourceContext,
+  inferClientBookingSourceFromProductIds,
+  type BookingSourceMetadata,
+} from '../../lib/booking/source-metadata';
+import { optionalCheckoutContactFields } from '../../lib/booking/checkout-contact';
+import { formatBookingRefForDisplay } from '../../lib/booking-ref';
+import type { CheckoutModalLineItem, CheckoutModalSummaryOverride } from './CheckoutModal';
+import type { Currency } from './CurrencySwitcher';
+
+export interface StandardCheckoutModalData {
+  reservationReference: string;
+  reservationExpiration?: string;
+  customerLastName?: string;
+  bookingDate?: string;
+  successUrlOverride?: string;
+  ticketLines: CheckoutModalLineItem[];
+  feeLineItems: OrderSummary['feeLineItems'];
+  returnPriceAdjustment: number;
+  cancellationPolicyFee: number;
+  cancellationPolicyLabel?: string;
+  subtotal: number;
+  tax: number;
+  total: number;
+  promoDiscountAmount?: number;
+  discountLabel?: string | null;
+  summaryOverride?: CheckoutModalSummaryOverride;
+  totalQuantity: number;
+  isTaxIncludedInPrice: boolean;
+  taxRate: number;
+  changeTotals?: {
+    previousTotal: number;
+    newTotal: number;
+    differenceTotal: number;
+  };
+}
+
+export interface StandardAdminChoiceData {
+  reservationReference: string;
+  reservationExpiration?: string;
+  checkoutBreakdown: CheckoutBreakdown;
+  totalAmount: number;
+  datePart: string;
+  timePart: string;
+  availabilityProductOptionId: string;
+  itineraryDisplay?: ItineraryDisplayStep[] | null;
+  clientSecret: string;
+  ticketLinesForModal: CheckoutModalLineItem[];
+  feeLineItems: OrderSummary['feeLineItems'];
+  returnPriceAdjustment: number;
+  cancellationPolicyFee: number;
+  cancellationPolicyLabel?: string;
+  subtotal: number;
+  tax: number;
+  totalQuantity: number;
+  isTaxIncludedInPrice: boolean;
+  taxRate: number;
+  promoDiscountAmount: number;
+  discountLabel?: string | null;
+  summaryOverride?: CheckoutModalSummaryOverride;
+  pricingQuoteId?: string;
+  pricingQuoteInputsHash?: string;
+}
+
+export interface BuildStandardAdminChoiceDataParams {
+  reservation: { reservationReference: string; expiresAt?: string };
+  checkoutBreakdown: CheckoutBreakdown;
+  totalAmount: number;
+  datePart: string;
+  timePart: string;
+  availabilityProductOptionId: string;
+  itineraryDisplay?: ItineraryDisplayStep[] | null;
+  clientSecret: string;
+  ticketLinesForModal: CheckoutModalLineItem[];
+  feeLineItems: OrderSummary['feeLineItems'];
+  returnPriceAdjustment: number;
+  cancellationPolicyFee: number;
+  cancellationPolicyLabel?: string;
+  subtotal: number;
+  tax: number;
+  totalQuantity: number;
+  isTaxIncludedInPrice: boolean;
+  taxRate: number;
+  promoDiscountAmount: number;
+  discountLabel?: string | null;
+  summaryOverride?: CheckoutModalSummaryOverride;
+  pricingQuoteId?: string;
+  pricingQuoteInputsHash?: string;
+}
+
+export function buildStandardAdminChoiceData({
+  reservation,
+  ...rest
+}: BuildStandardAdminChoiceDataParams): StandardAdminChoiceData {
+  return {
+    reservationReference: reservation.reservationReference,
+    reservationExpiration: reservation.expiresAt,
+    ...rest,
+  };
+}
+
+export interface BuildStandardPaidCheckoutModalDataParams {
+  reservation: { reservationReference: string; expiresAt?: string };
+  customerLastName: string;
+  bookingDate: string;
+  ticketLines: CheckoutModalLineItem[];
+  feeLineItems: OrderSummary['feeLineItems'];
+  returnPriceAdjustment: number;
+  cancellationPolicyFee: number;
+  cancellationPolicyLabel?: string;
+  subtotal: number;
+  tax: number;
+  total: number;
+  totalQuantity: number;
+  isTaxIncludedInPrice: boolean;
+  taxRate: number;
+  promoDiscountAmount: number;
+  discountLabel?: string | null;
+  summaryOverride?: CheckoutModalSummaryOverride;
+}
+
+export function buildStandardPaidCheckoutModalData({
+  reservation,
+  customerLastName,
+  bookingDate,
+  ticketLines,
+  feeLineItems,
+  returnPriceAdjustment,
+  cancellationPolicyFee,
+  cancellationPolicyLabel,
+  subtotal,
+  tax,
+  total,
+  totalQuantity,
+  isTaxIncludedInPrice,
+  taxRate,
+  promoDiscountAmount,
+  discountLabel,
+  summaryOverride,
+}: BuildStandardPaidCheckoutModalDataParams): StandardCheckoutModalData {
+  return {
+    reservationReference: reservation.reservationReference,
+    reservationExpiration: reservation.expiresAt,
+    customerLastName,
+    bookingDate,
+    successUrlOverride: undefined,
+    ticketLines,
+    feeLineItems,
+    returnPriceAdjustment,
+    cancellationPolicyFee,
+    cancellationPolicyLabel,
+    subtotal,
+    tax,
+    total,
+    totalQuantity,
+    isTaxIncludedInPrice,
+    taxRate,
+    promoDiscountAmount,
+    discountLabel,
+    summaryOverride,
+    changeTotals: undefined,
+  };
+}
+
+export function buildStandardPayNowCheckoutModalData(
+  adminChoiceData: StandardAdminChoiceData,
+  customerLastName: string
+): StandardCheckoutModalData {
+  return {
+    reservationReference: adminChoiceData.reservationReference,
+    reservationExpiration: adminChoiceData.reservationExpiration,
+    customerLastName,
+    ticketLines: adminChoiceData.ticketLinesForModal,
+    feeLineItems: adminChoiceData.feeLineItems,
+    returnPriceAdjustment: adminChoiceData.returnPriceAdjustment,
+    cancellationPolicyFee: adminChoiceData.cancellationPolicyFee,
+    cancellationPolicyLabel: adminChoiceData.cancellationPolicyLabel,
+    subtotal: adminChoiceData.subtotal,
+    tax: adminChoiceData.tax,
+    total: adminChoiceData.totalAmount,
+    totalQuantity: adminChoiceData.totalQuantity,
+    isTaxIncludedInPrice: adminChoiceData.isTaxIncludedInPrice,
+    taxRate: adminChoiceData.taxRate,
+    promoDiscountAmount: adminChoiceData.promoDiscountAmount,
+    discountLabel: adminChoiceData.discountLabel,
+    summaryOverride: adminChoiceData.summaryOverride,
+  };
+}
+
+export interface ConfirmStandardAdminBookingWithoutPaymentParams {
+  adminChoiceData: StandardAdminChoiceData;
+  bookingSourceAttribution: Partial<BookingSourceMetadata>;
+  partnerPortalBooking: boolean;
+  forceDashboardSource: boolean;
+  productId: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  phoneNumber: string;
+  currency: Currency;
+  travelerHotel?: string;
+  pickupLocationId?: string;
+  termsAcceptedAt?: string | null;
+  skipConfirmationCommunications: boolean;
+  disableAutoCommunications: boolean;
+}
+
+export async function confirmStandardAdminBookingWithoutPayment({
+  adminChoiceData,
+  bookingSourceAttribution,
+  partnerPortalBooking,
+  forceDashboardSource,
+  productId,
+  email,
+  firstName,
+  lastName,
+  phoneNumber,
+  currency,
+  travelerHotel,
+  pickupLocationId,
+  termsAcceptedAt,
+  skipConfirmationCommunications,
+  disableAutoCommunications,
+}: ConfirmStandardAdminBookingWithoutPaymentParams): Promise<{
+  bookingReference: string;
+  displayReference: string;
+  lastName: string;
+}> {
+  const bookingSourceContext = buildBookingSourceContext(bookingSourceAttribution, {
+    clientChannelSource: inferClientBookingSourceFromProductIds(
+      productId,
+      adminChoiceData.availabilityProductOptionId,
+    ),
+    forcePartnerPortalChannel: partnerPortalBooking,
+    forceDashboardSource,
+  });
+  const result = await confirmBookingWithoutPayment({
+    reservationReference: adminChoiceData.reservationReference,
+    productId,
+    optionId: adminChoiceData.availabilityProductOptionId,
+    date: adminChoiceData.datePart,
+    time: adminChoiceData.timePart,
+    customerEmail: email || undefined,
+    customerFirstName: firstName.trim() || undefined,
+    customerLastName: lastName.trim() || undefined,
+    ...optionalCheckoutContactFields(phoneNumber),
+    currency,
+    travelerHotel,
+    pickupLocationId,
+    itineraryDisplay: adminChoiceData.itineraryDisplay ?? undefined,
+    termsAcceptedAt: termsAcceptedAt ?? undefined,
+    skipConfirmationCommunications: skipConfirmationCommunications ? true : undefined,
+    disableAutoCommunications: disableAutoCommunications ? true : undefined,
+    checkoutBreakdown: adminChoiceData.checkoutBreakdown,
+    depositAmount: 0,
+    balanceAmount: adminChoiceData.totalAmount,
+    totalAmount: adminChoiceData.totalAmount,
+    pricingQuoteId: adminChoiceData.pricingQuoteId,
+    pricingQuoteInputsHash: adminChoiceData.pricingQuoteInputsHash,
+    ...bookingSourceContext,
+  });
+
+  return {
+    bookingReference: result.bookingReference,
+    displayReference: formatBookingRefForDisplay(result.bookingReference),
+    lastName: lastName.trim(),
+  };
+}

package/src/components/booking/standard-booking-reservation-runner.ts

@@ -0,0 +1,229 @@
+import {
+  createReservation,
+  describeStandardTourCapacityConflictMessage,
+  type Availability,
+  type ItineraryDisplayStep,
+  type PricingConfig,
+  type Product,
+  type PublicNewBookingQuoteV2Data,
+  type ReserveResponse,
+  type ReturnOption,
+} from '../../lib/booking-api';
+import { shouldReplacePricingConfig } from '../../lib/booking/pricing-config';
+import {
+  buildBookingSourceContext,
+  inferClientBookingSourceFromProductIds,
+  type BookingSourceMetadata,
+} from '../../lib/booking/source-metadata';
+import { quotePublicNewBookingV2ForCheckout } from '../../lib/pricing-v2-shadow';
+import type { Currency } from './CurrencySwitcher';
+import {
+  findMergedAvailabilityForSelection,
+  findMergedReturnVacancies,
+  getAvailabilityOptionId,
+} from './standard-booking-availability';
+
+type StandardBookingItem = { category: string; count: number };
+export type StandardAddOnSelection = { addOnId: string; variantId?: string; quantity?: number };
+type StandardBookingSourceContext = ReturnType<typeof buildBookingSourceContext>;
+
+export type StandardCheckoutReserveResult =
+  | { kind: 'blocked'; message: string }
+  | {
+      kind: 'ready';
+      bookingItems: StandardBookingItem[];
+      availabilityProductOptionId: string;
+      bookingSourceContext: StandardBookingSourceContext;
+      selectedPickupLocation: NonNullable<Product['pickupLocations']>[number] | null;
+      pricingV2Quote: PublicNewBookingQuoteV2Data | null;
+      reservation: ReserveResponse;
+      datePart: string;
+      timePart: string;
+      itineraryDisplay: ItineraryDisplayStep[] | null;
+    };
+
+export interface ReserveStandardBookingForCheckoutParams {
+  quantities: Record<string, number>;
+  selectedAvailability: Availability;
+  selectedReturnOption: ReturnOption | null;
+  product: Product;
+  pickupLocationId: string | null;
+  bookingSourceAttribution: Partial<BookingSourceMetadata>;
+  partnerPortalBooking: boolean;
+  forceDashboardSource: boolean;
+  isAdmin: boolean;
+  totalQuantity: number;
+  pricingConfig: PricingConfig | null;
+  refreshSelectedDateDetailsForCheckout: () => Promise<{
+    availabilities: Availability[];
+    pricingConfig?: PricingConfig | null;
+  }>;
+  displayTotalPrice: number;
+  totalPrice: number;
+  currency: Currency;
+  appliedPromoCode: string | null;
+  cancellationPolicyId: string | null;
+  addOnSelections: StandardAddOnSelection[];
+  itineraryDisplay: ItineraryDisplayStep[] | null;
+}
+
+function updatePendingStandardBookingSession({
+  reservation,
+  totalPrice,
+  currency,
+  selectedAvailability,
+}: {
+  reservation: ReserveResponse;
+  totalPrice: number;
+  currency: Currency;
+  selectedAvailability: Availability;
+}): void {
+  try {
+    const storedBooking = sessionStorage.getItem('pendingBooking');
+    if (!storedBooking) return;
+    const booking = JSON.parse(storedBooking);
+    booking.reservationReference = reservation.reservationReference;
+    booking.totalPrice = reservation.totalAmount || totalPrice;
+    booking.currency = reservation.currency || currency || selectedAvailability.currency || 'CAD';
+    sessionStorage.setItem('pendingBooking', JSON.stringify(booking));
+  } catch (e) {
+    console.warn('Failed to update booking data', e);
+  }
+}
+
+export async function reserveStandardBookingForCheckout({
+  quantities,
+  selectedAvailability,
+  selectedReturnOption,
+  product,
+  pickupLocationId,
+  bookingSourceAttribution,
+  partnerPortalBooking,
+  forceDashboardSource,
+  isAdmin,
+  totalQuantity,
+  pricingConfig,
+  refreshSelectedDateDetailsForCheckout,
+  displayTotalPrice,
+  totalPrice,
+  currency,
+  appliedPromoCode,
+  cancellationPolicyId,
+  addOnSelections,
+  itineraryDisplay,
+}: ReserveStandardBookingForCheckoutParams): Promise<StandardCheckoutReserveResult> {
+  const bookingItems = Object.entries(quantities)
+    .filter(([, count]) => count > 0)
+    .map(([category, count]) => ({ category, count }));
+  const availabilityProductOptionId = getAvailabilityOptionId(selectedAvailability);
+
+  if (!availabilityProductOptionId) {
+    return { kind: 'blocked', message: 'No product option selected' };
+  }
+
+  const bookingSourceContext = buildBookingSourceContext(bookingSourceAttribution, {
+    clientChannelSource: inferClientBookingSourceFromProductIds(
+      product.productId,
+      availabilityProductOptionId,
+    ),
+    forcePartnerPortalChannel: partnerPortalBooking,
+    forceDashboardSource,
+  });
+  const selectedPickupLocation = pickupLocationId
+    ? product.pickupLocations?.find((loc) => loc.id === pickupLocationId) ?? null
+    : null;
+
+  try {
+    const refreshed = await refreshSelectedDateDetailsForCheckout();
+    const outbound = findMergedAvailabilityForSelection(refreshed.availabilities, selectedAvailability);
+    const outboundVacancies = outbound?.vacancies ?? null;
+    const returnVacancies = findMergedReturnVacancies(outbound, selectedReturnOption);
+    if (
+      !isAdmin &&
+      ((outboundVacancies != null && outboundVacancies < totalQuantity) ||
+        (selectedReturnOption && returnVacancies != null && returnVacancies < totalQuantity))
+    ) {
+      return {
+        kind: 'blocked',
+        message: describeStandardTourCapacityConflictMessage({
+          partySize: totalQuantity,
+          outboundVacancies,
+          returnVacancies,
+          hasReturnSelection: !!selectedReturnOption,
+        }),
+      };
+    }
+    if (shouldReplacePricingConfig(pricingConfig, refreshed.pricingConfig)) {
+      return {
+        kind: 'blocked',
+        message: 'Pricing was refreshed. Please review the updated total and continue to payment again.',
+      };
+    }
+  } catch (refreshErr) {
+    console.warn('Fresh availability check failed before reserve; falling back to reserve validation.', refreshErr);
+  }
+
+  const pricingV2Quote = await quotePublicNewBookingV2ForCheckout({
+    flow: 'standard',
+    clientProposedTotal: displayTotalPrice,
+    request: {
+      productId: product.productId,
+      optionId: availabilityProductOptionId,
+      availabilityId: selectedAvailability.availabilityId || '',
+      dateTime: selectedAvailability.dateTime,
+      bookingItems,
+      currency,
+      returnAvailabilityId: selectedReturnOption?.returnAvailabilityId ?? null,
+      promoCode: appliedPromoCode || null,
+      cancellationPolicyId: cancellationPolicyId || null,
+      addOnSelections: addOnSelections.length > 0 ? addOnSelections : null,
+      ...(isAdmin ? { allowOverbook: true } : {}),
+    },
+  });
+
+  const reservation = await createReservation({
+    productId: availabilityProductOptionId,
+    dateTime: selectedAvailability.dateTime,
+    availabilityId: selectedAvailability.availabilityId || undefined,
+    bookingItems,
+    pickupLocationId: pickupLocationId || undefined,
+    returnAvailabilityId: selectedReturnOption?.returnAvailabilityId,
+    currency,
+    promoCode: appliedPromoCode || undefined,
+    cancellationPolicyId: cancellationPolicyId || undefined,
+    addOnSelections: addOnSelections.length > 0 ? addOnSelections : undefined,
+    ...(isAdmin ? { allowOverbook: true } : {}),
+    travelerHotel: selectedPickupLocation?.name || undefined,
+    ...(bookingSourceContext.sourceMetadata
+      ? {
+          source: bookingSourceContext.source,
+          sourceMetadata: bookingSourceContext.sourceMetadata,
+          source_metadata: bookingSourceContext.source_metadata,
+        }
+      : {}),
+  });
+
+  if (!reservation.reservationReference) {
+    throw new Error('Invalid reservation response: missing reservationReference');
+  }
+
+  updatePendingStandardBookingSession({
+    reservation,
+    totalPrice,
+    currency,
+    selectedAvailability,
+  });
+
+  return {
+    kind: 'ready',
+    bookingItems,
+    availabilityProductOptionId,
+    bookingSourceContext,
+    selectedPickupLocation,
+    pricingV2Quote,
+    reservation,
+    datePart: selectedAvailability.dateTime.split('T')[0],
+    timePart: selectedAvailability.dateTime.split('T')[1]?.substring(0, 5) || '00:00',
+    itineraryDisplay,
+  };
+}