@ticketboothapp/booking 1.2.123 → 1.2.124

package/src/components/booking/private-shuttle-payment-choice-runner.ts

@@ -0,0 +1,271 @@
+import {
+  confirmBookingWithoutPayment,
+  type CheckoutBreakdown,
+  type ItineraryDisplayStep,
+} from '../../lib/booking-api';
+import type { OrderSummaryFeeLine } 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 PrivateShuttleCheckoutModalData {
+  reservationReference: string;
+  reservationExpiration?: string;
+  customerLastName?: string;
+  bookingDate?: string;
+  ticketLines: CheckoutModalLineItem[];
+  feeLineItems: OrderSummaryFeeLine[];
+  returnPriceAdjustment: number;
+  subtotal: number;
+  tax: number;
+  total: number;
+  totalQuantity: number;
+  isTaxIncludedInPrice: boolean;
+  taxRate: number;
+  cancellationPolicyFee?: number;
+  cancellationPolicyLabel?: string;
+  promoDiscountAmount?: number;
+  discountLabel?: string | null;
+  summaryOverride?: CheckoutModalSummaryOverride;
+  isDepositPayment?: boolean;
+  balanceChargeDaysBefore?: number;
+}
+
+export interface PrivateShuttleAdminChoiceData {
+  reservationReference: string;
+  reservationExpiration?: string;
+  checkoutBreakdown: CheckoutBreakdown;
+  totalAmount: number;
+  datePart: string;
+  timePart: string;
+  availabilityProductOptionId: string;
+  itineraryDisplay?: ItineraryDisplayStep[] | null;
+  clientSecret: string;
+  ticketLinesForModal: CheckoutModalLineItem[];
+  feeLineItems: OrderSummaryFeeLine[];
+  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 BuildPrivateShuttleAdminChoiceDataParams {
+  reservation: { reservationReference: string; expiresAt?: string };
+  checkoutBreakdown: CheckoutBreakdown;
+  totalAmount: number;
+  datePart: string;
+  timePart: string;
+  availabilityProductOptionId: string;
+  itineraryDisplay?: ItineraryDisplayStep[] | null;
+  clientSecret: string;
+  ticketLinesForModal: CheckoutModalLineItem[];
+  feeLineItems: OrderSummaryFeeLine[];
+  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 buildPrivateShuttleAdminChoiceData({
+  reservation,
+  ...rest
+}: BuildPrivateShuttleAdminChoiceDataParams): PrivateShuttleAdminChoiceData {
+  return {
+    reservationReference: reservation.reservationReference,
+    reservationExpiration: reservation.expiresAt,
+    ...rest,
+  };
+}
+
+export interface BuildPrivateShuttlePaidCheckoutModalDataParams {
+  reservation: { reservationReference: string; expiresAt?: string };
+  customerLastName: string;
+  bookingDate: string;
+  ticketLines: CheckoutModalLineItem[];
+  feeLineItems: OrderSummaryFeeLine[];
+  subtotal: number;
+  tax: number;
+  total: number;
+  totalQuantity: number;
+  isTaxIncludedInPrice: boolean;
+  taxRate: number;
+  cancellationPolicyFee?: number;
+  cancellationPolicyLabel?: string;
+  promoDiscountAmount: number;
+  discountLabel?: string | null;
+  summaryOverride?: CheckoutModalSummaryOverride;
+  isDepositPayment: boolean;
+  balanceChargeDaysBefore?: number;
+}
+
+export function buildPrivateShuttlePaidCheckoutModalData({
+  reservation,
+  customerLastName,
+  bookingDate,
+  ticketLines,
+  feeLineItems,
+  subtotal,
+  tax,
+  total,
+  totalQuantity,
+  isTaxIncludedInPrice,
+  taxRate,
+  cancellationPolicyFee,
+  cancellationPolicyLabel,
+  promoDiscountAmount,
+  discountLabel,
+  summaryOverride,
+  isDepositPayment,
+  balanceChargeDaysBefore,
+}: BuildPrivateShuttlePaidCheckoutModalDataParams): PrivateShuttleCheckoutModalData {
+  return {
+    reservationReference: reservation.reservationReference,
+    reservationExpiration: reservation.expiresAt,
+    customerLastName,
+    bookingDate,
+    ticketLines,
+    feeLineItems,
+    returnPriceAdjustment: 0,
+    subtotal,
+    tax,
+    total,
+    totalQuantity,
+    isTaxIncludedInPrice,
+    taxRate,
+    cancellationPolicyFee,
+    cancellationPolicyLabel,
+    promoDiscountAmount,
+    discountLabel,
+    summaryOverride,
+    isDepositPayment,
+    balanceChargeDaysBefore,
+  };
+}
+
+export function buildPrivateShuttlePayNowCheckoutModalData(
+  adminChoiceData: PrivateShuttleAdminChoiceData,
+  customerLastName: string
+): PrivateShuttleCheckoutModalData {
+  return {
+    reservationReference: adminChoiceData.reservationReference,
+    reservationExpiration: adminChoiceData.reservationExpiration,
+    customerLastName,
+    bookingDate: adminChoiceData.datePart,
+    ticketLines: adminChoiceData.ticketLinesForModal,
+    feeLineItems: adminChoiceData.feeLineItems,
+    returnPriceAdjustment: 0,
+    subtotal: adminChoiceData.subtotal,
+    tax: adminChoiceData.tax,
+    total: adminChoiceData.totalAmount,
+    totalQuantity: adminChoiceData.totalQuantity,
+    isTaxIncludedInPrice: adminChoiceData.isTaxIncludedInPrice,
+    taxRate: adminChoiceData.taxRate,
+    cancellationPolicyFee: adminChoiceData.cancellationPolicyFee,
+    cancellationPolicyLabel: adminChoiceData.cancellationPolicyLabel,
+    promoDiscountAmount: adminChoiceData.promoDiscountAmount,
+    discountLabel: adminChoiceData.discountLabel,
+    summaryOverride: adminChoiceData.summaryOverride,
+  };
+}
+
+export interface ConfirmPrivateShuttleAdminBookingWithoutPaymentParams {
+  adminChoiceData: PrivateShuttleAdminChoiceData;
+  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 confirmPrivateShuttleAdminBookingWithoutPayment({
+  adminChoiceData,
+  bookingSourceAttribution,
+  partnerPortalBooking,
+  forceDashboardSource,
+  productId,
+  email,
+  firstName,
+  lastName,
+  phoneNumber,
+  currency,
+  travelerHotel,
+  pickupLocationId,
+  termsAcceptedAt,
+  skipConfirmationCommunications,
+  disableAutoCommunications,
+}: ConfirmPrivateShuttleAdminBookingWithoutPaymentParams): 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/private-shuttle-provider-change-runner.ts

@@ -0,0 +1,73 @@
+import type {
+  ProviderDashboardChangeBookingPayload,
+  ProviderDashboardInitialBooking,
+} from './provider-dashboard-change-booking';
+import type { PrivateShuttleAddOnSelection } from './private-shuttle-reservation-runner';
+
+export interface ApplyPrivateShuttleProviderChangeParams {
+  onChangeBooking: (data: ProviderDashboardChangeBookingPayload) => Promise<void>;
+  selectedOption: string;
+  selectedDate: string;
+  selectedStartTime: string;
+  billableResourceCount: number;
+  pickupLocationId: string | null;
+  selectedPickupLocationName?: string | null;
+  customPickupAddress?: string | null;
+  initialBooking?: ProviderDashboardInitialBooking;
+  passengerCount: number;
+  childSafetySeatsCount: number;
+  foodRestrictions: string;
+  addOnSelections: PrivateShuttleAddOnSelection[];
+  cancellationPolicyId: string | null;
+  activePromoCode: string | null;
+  totalPrice: number;
+  additionalHoursCount: number;
+  isAdmin: boolean;
+  providerChangeAuthoritativeReceipt?: ProviderDashboardChangeBookingPayload['authoritativeReceipt'];
+}
+
+export async function applyPrivateShuttleProviderChange({
+  onChangeBooking,
+  selectedOption,
+  selectedDate,
+  selectedStartTime,
+  billableResourceCount,
+  pickupLocationId,
+  selectedPickupLocationName,
+  customPickupAddress,
+  initialBooking,
+  passengerCount,
+  childSafetySeatsCount,
+  foodRestrictions,
+  addOnSelections,
+  cancellationPolicyId,
+  activePromoCode,
+  totalPrice,
+  additionalHoursCount,
+  isAdmin,
+  providerChangeAuthoritativeReceipt,
+}: ApplyPrivateShuttleProviderChangeParams): Promise<void> {
+  const bookingItems = [{ category: 'RESOURCE' as const, count: billableResourceCount }];
+  const [hours, minutes] = selectedStartTime.split(':').map(Number);
+  const startTimeISO = `${selectedDate}T${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:00-06:00`;
+
+  await onChangeBooking({
+    productId: selectedOption,
+    dateTime: selectedDate,
+    bookingItems,
+    returnAvailabilityId: null,
+    pickupLocationId: pickupLocationId ?? null,
+    travelerHotel:
+      selectedPickupLocationName ?? customPickupAddress ?? initialBooking?.travelerHotel ?? null,
+    startTime: startTimeISO,
+    passengerCount,
+    childSafetySeatsCount: childSafetySeatsCount > 0 ? childSafetySeatsCount : null,
+    foodRestrictions: foodRestrictions.trim() || null,
+    addOnSelections: addOnSelections.length > 0 ? addOnSelections : null,
+    cancellationPolicyId: cancellationPolicyId ?? initialBooking?.cancellationPolicyId ?? null,
+    promoCode: activePromoCode ?? null,
+    newTotalAmount: totalPrice,
+    additionalHoursCount: isAdmin ? additionalHoursCount : null,
+    authoritativeReceipt: providerChangeAuthoritativeReceipt,
+  });
+}

package/src/components/booking/private-shuttle-reservation-runner.ts

@@ -0,0 +1,260 @@
+import {
+  createReservation,
+  describePrivateShuttleCapacityConflictMessage,
+  type Availability,
+  type ItineraryDisplayStep,
+  ItineraryStepType,
+  type PricingConfig,
+  type PublicNewBookingQuoteV2Data,
+  type ReserveResponse,
+} 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 { findMergedPrivateShuttleAvailability } from './private-shuttle-availability';
+
+type PrivateShuttleBookingItem = { category: 'RESOURCE'; count: number };
+export type PrivateShuttleAddOnSelection = { addOnId: string; variantId?: string; quantity?: number };
+type PrivateShuttleBookingSourceContext = ReturnType<typeof buildBookingSourceContext>;
+
+export type PrivateShuttleCheckoutItineraryItem = {
+  time: string | null;
+  label: string;
+  clickableLabel?: string;
+  prefix?: string;
+  timesNote?: string;
+  isProposedStops?: boolean;
+};
+
+export type PrivateShuttleCheckoutReserveResult =
+  | { kind: 'blocked'; message: string }
+  | {
+      kind: 'ready';
+      bookingItems: PrivateShuttleBookingItem[];
+      bookingSourceContext: PrivateShuttleBookingSourceContext;
+      startTimeISO: string;
+      pricingV2Quote: PublicNewBookingQuoteV2Data | null;
+      reservation: ReserveResponse;
+      itineraryDisplayForStorage: ItineraryDisplayStep[];
+    };
+
+export interface ReservePrivateShuttleForCheckoutParams {
+  selectedOption: string;
+  selectedDate: string;
+  selectedStartTime: string;
+  selectedAvailability: Availability | null;
+  companyTimezone: string;
+  productId: string;
+  currency: Currency;
+  bookingSourceAttribution: Partial<BookingSourceMetadata>;
+  partnerPortalBooking: boolean;
+  forceDashboardSource: boolean;
+  isAdmin: boolean;
+  isSpecialRequest: boolean;
+  passengerCount: number;
+  maxVacancies: number;
+  billableResourceCount: number;
+  resourceCount: number;
+  pricingConfig: PricingConfig | null;
+  refreshSelectedDateDetailsForCheckout: () => Promise<{
+    availabilities: Availability[];
+    pricingConfig?: PricingConfig | null;
+  }>;
+  totalPrice: number;
+  activePromoCode: string | null;
+  cancellationPolicyId: string | null;
+  addOnSelections: PrivateShuttleAddOnSelection[];
+  additionalHoursCount: number;
+  selectedPickupLocationName?: string | null;
+  customPickupAddress?: string | null;
+  pickupLocationId: string | null;
+  draftItineraryDestinations: string[];
+  draftItineraryPlanningNotes: string;
+  childSafetySeatsCount: number;
+  foodRestrictions: string;
+  itineraryDisplayItems: PrivateShuttleCheckoutItineraryItem[];
+}
+
+function buildPrivateShuttleItineraryDisplayForStorage(
+  itineraryDisplayItems: PrivateShuttleCheckoutItineraryItem[]
+): ItineraryDisplayStep[] {
+  return itineraryDisplayItems.map((item, i) => {
+    if (item.isProposedStops) {
+      return {
+        stepType: ItineraryStepType.draft,
+        time: 'Proposed stops',
+        place: item.label,
+      };
+    }
+    const isPickup = i === 0;
+    return {
+      stepType: isPickup ? ItineraryStepType.pickup : ItineraryStepType.drop_off,
+      time: item.time ?? 'TBD',
+      place: item.clickableLabel ?? item.label,
+    };
+  });
+}
+
+export async function reservePrivateShuttleForCheckout({
+  selectedOption,
+  selectedDate,
+  selectedStartTime,
+  selectedAvailability,
+  companyTimezone,
+  productId,
+  currency,
+  bookingSourceAttribution,
+  partnerPortalBooking,
+  forceDashboardSource,
+  isAdmin,
+  isSpecialRequest,
+  passengerCount,
+  maxVacancies,
+  billableResourceCount,
+  resourceCount,
+  pricingConfig,
+  refreshSelectedDateDetailsForCheckout,
+  totalPrice,
+  activePromoCode,
+  cancellationPolicyId,
+  addOnSelections,
+  additionalHoursCount,
+  selectedPickupLocationName,
+  customPickupAddress,
+  pickupLocationId,
+  draftItineraryDestinations,
+  draftItineraryPlanningNotes,
+  childSafetySeatsCount,
+  foodRestrictions,
+  itineraryDisplayItems,
+}: ReservePrivateShuttleForCheckoutParams): Promise<PrivateShuttleCheckoutReserveResult> {
+  if (!selectedOption) {
+    return { kind: 'blocked', message: 'No product option selected' };
+  }
+
+  const bookingSourceContext = buildBookingSourceContext(bookingSourceAttribution, {
+    clientChannelSource: inferClientBookingSourceFromProductIds(productId, selectedOption),
+    forcePartnerPortalChannel: partnerPortalBooking,
+    forceDashboardSource,
+  });
+  const bookingItems: PrivateShuttleBookingItem[] = [
+    { category: 'RESOURCE', count: billableResourceCount },
+  ];
+  const [hours, minutes] = selectedStartTime.split(':').map(Number);
+  const startTimeISO = `${selectedDate}T${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:00-06:00`;
+
+  try {
+    const refreshed = await refreshSelectedDateDetailsForCheckout();
+    const slot = findMergedPrivateShuttleAvailability(
+      refreshed.availabilities,
+      selectedAvailability,
+      selectedOption || null,
+      selectedDate || null,
+      companyTimezone
+    );
+    const passengersToReserve = isSpecialRequest
+      ? Math.min(passengerCount, maxVacancies)
+      : passengerCount;
+    if (!isAdmin && slot?.vacancies != null && (slot.vacancies === 0 || slot.vacancies < passengersToReserve)) {
+      return {
+        kind: 'blocked',
+        message: describePrivateShuttleCapacityConflictMessage({
+          passengersRequested: passengerCount,
+          vacancies: slot.vacancies,
+        }),
+      };
+    }
+    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 private shuttle availability check failed before reserve; falling back to reserve validation.', refreshErr);
+  }
+
+  const specialRequestNote = isSpecialRequest
+    ? `Special request: Customer requested ${passengerCount} passengers (${resourceCount} shuttles needed). We reserved ${billableResourceCount} at standard capacity. Team to add ${resourceCount - billableResourceCount} more shuttle(s) and verify fleet availability.`
+    : '';
+  const userPlanningNotes = draftItineraryPlanningNotes.trim();
+  const planningNotes = [specialRequestNote, userPlanningNotes].filter(Boolean).join('\n\n');
+  const selectedAvailabilityId = selectedAvailability?.availabilityId;
+  if (!selectedAvailabilityId) {
+    return {
+      kind: 'blocked',
+      message: 'Please choose an available date before continuing.',
+    };
+  }
+
+  const pricingV2Quote = await quotePublicNewBookingV2ForCheckout({
+    flow: 'private-shuttle',
+    clientProposedTotal: totalPrice,
+    request: {
+      productId,
+      optionId: selectedOption,
+      availabilityId: selectedAvailabilityId,
+      dateTime: selectedAvailability?.dateTime || selectedDate,
+      bookingItems,
+      currency,
+      promoCode: activePromoCode || null,
+      cancellationPolicyId: cancellationPolicyId || null,
+      addOnSelections: addOnSelections.length > 0 ? addOnSelections : null,
+      additionalHoursCount: isAdmin && additionalHoursCount > 0 ? additionalHoursCount : null,
+      ...(isAdmin ? { allowOverbook: true } : {}),
+    },
+  });
+
+  const reservation = await createReservation({
+    productId: selectedOption,
+    dateTime: selectedDate,
+    availabilityId: selectedAvailabilityId,
+    bookingItems,
+    currency,
+    startTime: startTimeISO,
+    passengerCount: isSpecialRequest ? Math.min(passengerCount, maxVacancies) : passengerCount,
+    requestedPassengerCount: isSpecialRequest ? passengerCount : undefined,
+    pickupLocationId: pickupLocationId || undefined,
+    cancellationPolicyId: cancellationPolicyId || undefined,
+    promoCode: activePromoCode || undefined,
+    travelerHotel: selectedPickupLocationName || customPickupAddress || undefined,
+    draftItinerary:
+      draftItineraryDestinations.length > 0 || planningNotes
+        ? {
+            destinations: draftItineraryDestinations,
+            planningNotes: planningNotes || undefined,
+          }
+        : undefined,
+    childSafetySeatsCount: childSafetySeatsCount > 0 ? childSafetySeatsCount : undefined,
+    foodRestrictions: foodRestrictions.trim() || undefined,
+    addOnSelections: addOnSelections.length > 0 ? addOnSelections : undefined,
+    additionalHoursCount: isAdmin && additionalHoursCount > 0 ? additionalHoursCount : undefined,
+    ...(isAdmin ? { allowOverbook: true } : {}),
+    ...(bookingSourceContext.sourceMetadata
+      ? {
+          source: bookingSourceContext.source,
+          sourceMetadata: bookingSourceContext.sourceMetadata,
+          source_metadata: bookingSourceContext.source_metadata,
+        }
+      : {}),
+  });
+
+  if (!reservation?.reservationReference) {
+    throw new Error('Invalid reservation response: missing reservationReference');
+  }
+
+  return {
+    kind: 'ready',
+    bookingItems,
+    bookingSourceContext,
+    startTimeISO,
+    pricingV2Quote,
+    reservation,
+    itineraryDisplayForStorage: buildPrivateShuttleItineraryDisplayForStorage(itineraryDisplayItems),
+  };
+}