@ticketboothapp/booking 1.2.24 → 1.2.25

package/src/lib/booking/pricing.ts

@@ -0,0 +1,466 @@
+import type { Currency } from '@/components/booking/CurrencySwitcher';
+import type { PricingConfig } from '@/lib/booking-api';
+import { DEFAULT_EXCHANGE_RATES } from '@/lib/currency';
+
+const BASE_CURRENCY = 'CAD' as const;
+
+/**
+ * Validate that pricingConfig has required fields and valid values.
+ * Returns true if valid, logs warnings and returns false if invalid.
+ */
+export function validatePricingConfig(config: PricingConfig | null): config is PricingConfig {
+  if (!config) {
+    console.warn('[Pricing] pricingConfig is null or undefined');
+    return false;
+  }
+
+  if (typeof config.taxRate !== 'number' || config.taxRate <= 0 || config.taxRate > 1) {
+    console.warn('[Pricing] Invalid taxRate:', config.taxRate);
+    return false;
+  }
+
+  if (!Array.isArray(config.currenciesWithTaxIncluded)) {
+    console.warn('[Pricing] currenciesWithTaxIncluded must be an array');
+    return false;
+  }
+
+  if (config.fees != null && typeof config.fees !== 'object') {
+    console.warn('[Pricing] fees must be an object when present');
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Get exchange rates from pricingConfig with fallback to defaults.
+ * Logs a warning if fallback is used.
+ */
+function getExchangeRates(pricingConfig: PricingConfig): Record<string, number> {
+  if (pricingConfig.exchangeRates && Object.keys(pricingConfig.exchangeRates).length > 0) {
+    return pricingConfig.exchangeRates;
+  }
+
+  console.warn('[Pricing] Exchange rates not provided in pricingConfig, using fallback rates');
+  return {
+    USD: DEFAULT_EXCHANGE_RATES.USD,
+    EUR: DEFAULT_EXCHANGE_RATES.EUR,
+    GBP: DEFAULT_EXCHANGE_RATES.GBP,
+    AUD: DEFAULT_EXCHANGE_RATES.AUD,
+  };
+}
+
+/** Tax rate as display percentage (e.g. 0.05 → 5, 0.085 → 8.5). UI displays only; no calculation in UI. */
+export function formatTaxRatePercent(taxRate: number): number {
+  return Math.round(taxRate * 10000) / 100;
+}
+
+/**
+ * Internal: compute ticket price and all intermediates. Single place for pricing logic.
+ * Must stay in sync with BE when generating prices (rounding only on BE).
+ * When baseInDisplayCurrency is provided (e.g. from precomputedPrices), use it as the backend
+ * price in display currency so the breakdown matches the displayed ticket price.
+ */
+function computeTicketPriceDetails(
+  pricingConfig: PricingConfig,
+  currency: Currency,
+  backendPriceCAD: number,
+  hasFees: boolean,
+  baseInDisplayCurrency?: number
+): {
+  finalPrice: number;
+  priceAfterConversion: number;
+  feeAmount: number;
+  feeLines: Array<{ name: string; feeAmount: number; description?: string }>;
+  taxAmount: number;
+  isTaxIncluded: boolean;
+  exchangeRate: number;
+} {
+  const exchangeRates = getExchangeRates(pricingConfig);
+  const isTaxIncluded = pricingConfig.currenciesWithTaxIncluded.includes(currency);
+  const byCurrency = hasFees ? pricingConfig.feesByCurrency?.[currency] : undefined;
+  const fees = pricingConfig.fees ?? {};
+  const feeLines =
+    byCurrency != null
+      ? Object.entries(byCurrency).map(([name, amount]) => ({
+          name,
+          feeAmount: amount,
+          description: fees[name]?.description,
+        }))
+      : [];
+  const feeAmount = feeLines.reduce((sum, f) => sum + f.feeAmount, 0);
+
+  let priceAfterConversion: number;
+  let finalPrice: number;
+  let taxAmount: number;
+
+  const usePrecomputedBase = baseInDisplayCurrency != null && currency !== BASE_CURRENCY;
+
+  if (isTaxIncluded) {
+    priceAfterConversion = usePrecomputedBase
+      ? baseInDisplayCurrency!
+      : (currency === BASE_CURRENCY ? backendPriceCAD : 0);
+    const preTaxAmount = priceAfterConversion + feeAmount;
+    finalPrice = preTaxAmount * (1 + pricingConfig.taxRate);
+    taxAmount = preTaxAmount * pricingConfig.taxRate;
+  } else {
+    if (currency === BASE_CURRENCY) {
+      priceAfterConversion = backendPriceCAD;
+      finalPrice = backendPriceCAD;
+    } else {
+      priceAfterConversion = usePrecomputedBase ? baseInDisplayCurrency! : 0;
+      finalPrice = priceAfterConversion;
+    }
+    taxAmount = 0;
+  }
+
+  const exchangeRate = currency === BASE_CURRENCY ? 1 : (exchangeRates[currency] ?? 1);
+
+  return {
+    finalPrice,
+    priceAfterConversion,
+    feeAmount,
+    feeLines,
+    taxAmount,
+    isTaxIncluded,
+    exchangeRate,
+  };
+}
+
+/**
+ * Display price per ticket when base is already in display currency (from ticketbooth-product-prices).
+ * For CAD/USD: returns base (fee/tax shown as separate line items).
+ * For EUR/GBP/AUD: returns (base + fee per person) * (1 + tax).
+ */
+export function getDisplayPriceFromBaseInDisplayCurrency(
+  baseInDisplayCurrency: number,
+  currency: Currency,
+  pricingConfig: PricingConfig,
+  hasFees: boolean
+): number {
+  if (baseInDisplayCurrency <= 0) return 0;
+  if (!validatePricingConfig(pricingConfig)) return 0;
+  const isTaxIncluded = pricingConfig.currenciesWithTaxIncluded.includes(currency);
+  const byCurrency = hasFees ? pricingConfig.feesByCurrency?.[currency] : undefined;
+  const feeAmount =
+    byCurrency != null ? Object.values(byCurrency).reduce((s, a) => s + a, 0) : 0;
+  if (isTaxIncluded) {
+    return (baseInDisplayCurrency + feeAmount) * (1 + pricingConfig.taxRate);
+  }
+  return baseInDisplayCurrency;
+}
+
+/** Applied adjustment from API. BE sends changeByCurrency; FE uses that amount only (no conversion). */
+export interface PriceBreakdownAdjustment {
+  type: string;
+  id: string;
+  name: string;
+  changeByCurrency?: Record<string, number>;
+  adjustmentType?: string; // "percentage" or "fixed"
+  adjustmentValue?: number; // e.g. -10.0 for 10% off, or fixed amount in CAD
+}
+
+// --- Mid-layer: price breakdown (no UI). Use this output in tooltip, summary, etc. ---
+
+/** One line in the price breakdown. Amount is in display currency (from BE). */
+export interface PriceBreakdownLineItem {
+  type: 'base' | 'adjustment';
+  id?: string;
+  name: string;
+  amountInDisplayCurrency: number;
+  adjustmentType?: string; // "percentage" or "fixed"
+  adjustmentValue?: number; // e.g. 10.0 for 10%, or fixed amount in CAD
+  sourceType?: 'deal' | 'dynamic'; // Whether this adjustment is from a deal or dynamic pricing rule
+}
+
+/** Result of the price breakdown calculation. Consume in tooltip, order summary, or any other booking UI. */
+export interface PriceBreakdown {
+  lineItems: PriceBreakdownLineItem[];
+  subtotalAfterAdjustments: number;
+  feeLines: FeeLineForDisplay[];
+  taxRate: number;
+  taxAmount: number;
+  isTaxIncluded: boolean;
+  finalPrice: number;
+}
+
+/** One fee line for tooltip display (name from config, amount per person in display currency from BE). */
+export interface FeeLineForDisplay {
+  name: string;
+  feeAmount: number;
+  description?: string;
+}
+
+/** Full breakdown for price tooltip. Must match computeTicketPriceDetails logic. */
+export interface PriceBreakdownForDisplay {
+  /** Only true when we convert in mid-layer (e.g. backend price → display currency); show rate only then. */
+  showConversionRate: boolean;
+  exchangeRate: number;
+  /** Base price in display currency — from ticketbooth-product-prices (via API) for every currency including CAD when available. */
+  basePriceInDisplayCurrency: number;
+  /** Backend price (base + dynamic pricing/deals) in display currency; this is the ticket price before fees/tax. */
+  backendPriceInDisplayCurrency: number;
+  feeAmount: number;
+  feeLines: FeeLineForDisplay[];
+  taxRate: number;
+  taxAmount: number;
+  /** Reserved for future rounding; currently 0. Rounding only on BE when generating prices. */
+  roundingAmount: number;
+  isTaxIncluded: boolean;
+  finalPrice: number;
+}
+
+/**
+ * Build step-by-step breakdown for tooltip. Uses same logic as computeTicketPriceDetails.
+ * Base price comes from ticketbooth-product-prices (via API) for every currency including CAD when provided; never converted on the FE.
+ * Conversion rate is only shown when we convert backend (add-ons/dynamic/deals) on the FE.
+ */
+export function getPriceBreakdownForDisplay(
+  pricingConfig: PricingConfig,
+  currency: Currency,
+  backendPriceCAD: number,
+  basePriceCAD: number,
+  hasFees: boolean,
+  appliedAdjustments: PriceBreakdownAdjustment[],
+  baseInDisplayCurrency?: number,
+  basePriceInDisplayCurrencyFromApi?: number
+): PriceBreakdownForDisplay {
+  const details = computeTicketPriceDetails(
+    pricingConfig,
+    currency,
+    backendPriceCAD,
+    hasFees,
+    baseInDisplayCurrency
+  );
+
+  const showConversionRate =
+    currency !== BASE_CURRENCY && baseInDisplayCurrency == null;
+
+  // Base price: from ticketbooth-product-prices (via API) for every currency including CAD when provided; else fallback to product-option CAD only when currency is CAD.
+  const basePriceInDisplayCurrency =
+    basePriceInDisplayCurrencyFromApi ??
+    (currency === BASE_CURRENCY ? basePriceCAD : 0);
+
+  return {
+    showConversionRate,
+    exchangeRate: details.exchangeRate,
+    basePriceInDisplayCurrency,
+    backendPriceInDisplayCurrency: details.priceAfterConversion,
+    feeAmount: details.feeAmount,
+    feeLines: details.feeLines,
+    taxRate: pricingConfig.taxRate,
+    taxAmount: details.taxAmount,
+    roundingAmount: 0,
+    isTaxIncluded: details.isTaxIncluded,
+    finalPrice: details.finalPrice,
+  };
+}
+
+/**
+ * Mid-layer: compute price breakdown as line items (base + one per adjustment). No UI.
+ * Use the result in tooltip, order summary, or anywhere in the booking UI.
+ * - Base: from ticketbooth-product-prices (via API) for every currency including CAD when provided; never converted on FE.
+ * - Adjustments: BE sends changeByCurrency; FE uses that amount only (no conversion).
+ * - Exchange rate is never a separate line; show in brackets on each line that used conversion.
+ * 
+ * @param isPublicMode - When true (simplified view), rolls dynamic pricing increases into base price and hides them
+ */
+export function computePriceBreakdown(
+  pricingConfig: PricingConfig,
+  currency: Currency,
+  backendPriceCAD: number,
+  basePriceCAD: number,
+  hasFees: boolean,
+  appliedAdjustments: PriceBreakdownAdjustment[],
+  baseInDisplayCurrency?: number,
+  basePriceInDisplayCurrencyFromApi?: number,
+  isPublicMode?: boolean
+): PriceBreakdown {
+  const baseAmount =
+    basePriceInDisplayCurrencyFromApi ??
+    (currency === BASE_CURRENCY ? basePriceCAD : 0);
+
+  const lineItems: PriceBreakdownLineItem[] = [];
+  
+  // For public mode: calculate which dynamic adjustments are increases (to be rolled into base)
+  let dynamicIncreaseSum = 0;
+  if (isPublicMode) {
+    for (const adj of appliedAdjustments) {
+      const amountInDisplayCurrency = adj.changeByCurrency?.[currency];
+      if (amountInDisplayCurrency == null || amountInDisplayCurrency === 0) continue;
+      
+      // Dynamic pricing increase: roll into base price, don't show separately
+      if (adj.type === 'dynamic' && amountInDisplayCurrency > 0) {
+        dynamicIncreaseSum += amountInDisplayCurrency;
+      }
+    }
+  }
+
+  // Base price (with dynamic increases rolled in for public mode)
+  const displayBaseAmount = baseAmount + dynamicIncreaseSum;
+  if (displayBaseAmount > 0) {
+    lineItems.push({
+      type: 'base',
+      name: isPublicMode && dynamicIncreaseSum > 0 ? 'Dynamic price' : 'Base price',
+      amountInDisplayCurrency: displayBaseAmount,
+    });
+  }
+
+  let adjustmentSum = 0;
+  for (const adj of appliedAdjustments) {
+    const amountInDisplayCurrency = adj.changeByCurrency?.[currency];
+    if (amountInDisplayCurrency == null || amountInDisplayCurrency === 0) continue;
+
+    // In public mode: skip dynamic pricing increases (they're rolled into base)
+    if (isPublicMode && adj.type === 'dynamic' && amountInDisplayCurrency > 0) {
+      adjustmentSum += amountInDisplayCurrency; // Still count for subtotal calculation
+      continue; // Don't add to lineItems
+    }
+
+    adjustmentSum += amountInDisplayCurrency;
+    lineItems.push({
+      type: 'adjustment',
+      id: adj.id,
+      name: adj.name,
+      amountInDisplayCurrency,
+      adjustmentType: adj.adjustmentType,
+      adjustmentValue: adj.adjustmentValue,
+      sourceType: adj.type === 'deal' || adj.type === 'dynamic' ? adj.type : undefined,
+    });
+  }
+
+  // Subtotal in display currency = base + adjustments; pass so final price is (subtotal + fees) * (1+tax) and breakdown adds up
+  const subtotalInDisplayCurrency = baseAmount + adjustmentSum;
+  const details = computeTicketPriceDetails(
+    pricingConfig,
+    currency,
+    backendPriceCAD,
+    hasFees,
+    subtotalInDisplayCurrency > 0 ? subtotalInDisplayCurrency : baseInDisplayCurrency
+  );
+
+  return {
+    lineItems,
+    subtotalAfterAdjustments: details.priceAfterConversion,
+    feeLines: details.feeLines,
+    taxRate: pricingConfig.taxRate,
+    taxAmount: details.taxAmount,
+    isTaxIncluded: details.isTaxIncluded,
+    finalPrice: details.finalPrice,
+  };
+}
+
+/** One fee line for order summary (name, total amount in display currency, optional description). */
+export interface OrderSummaryFeeLine {
+  name: string;
+  totalAmount: number;
+  description?: string;
+}
+
+/** One ticket line for order summary (category, qty, price per unit, item total in display currency). */
+export interface OrderSummaryTicketLine {
+  category: string;
+  qty: number;
+  pricePerUnit: number;
+  itemTotal: number;
+}
+
+/** Order summary for booking flow: all values in display currency. UI displays only; no calculations. */
+export interface OrderSummary {
+  subtotal: number;
+  tax: number;
+  total: number;
+  feeLineItems: OrderSummaryFeeLine[];
+  returnPriceAdjustment: number;
+  /** Per-booking fee for upgraded (flexible) cancellation when selected; 0 otherwise. */
+  cancellationPolicyFee: number;
+  totalQuantity: number;
+  isTaxIncludedInPrice: boolean;
+  /** Ticket lines with itemTotal so UI does not compute qty × price. */
+  ticketLineItems: OrderSummaryTicketLine[];
+}
+
+/**
+ * Compute order summary (subtotal, tax, total, fee lines, return adjustment, cancellation upgrade) in display currency.
+ * Single source of truth for booking flow totals; UI layer only displays these values.
+ * Return adjustment: use selectedReturnOption.priceAdjustmentByCurrency[currency] only.
+ * Cancellation fee: use pricingConfig.cancellationPolicies[id].feeByCurrency[currency] when cancellationPolicyId is set.
+ */
+export function computeOrderSummary(
+  quantities: Record<string, number>,
+  pricing: Array<{ category: string; price: number }>,
+  selectedReturnOption: { priceAdjustmentByCurrency?: Record<string, number> } | null,
+  pricingConfig: PricingConfig | null,
+  currency: Currency,
+  hasFees: boolean,
+  cancellationPolicyId?: string | null
+): OrderSummary {
+  const totalQuantity = Object.values(quantities).reduce((a, b) => a + b, 0);
+
+  if (!pricingConfig || !validatePricingConfig(pricingConfig)) {
+    return {
+      subtotal: 0,
+      tax: 0,
+      total: 0,
+      feeLineItems: [],
+      returnPriceAdjustment: 0,
+      cancellationPolicyFee: 0,
+      totalQuantity,
+      isTaxIncludedInPrice: false,
+      ticketLineItems: [],
+    };
+  }
+
+  const isTaxIncludedInPrice = pricingConfig.currenciesWithTaxIncluded.includes(currency);
+
+  const basePrice = pricing.reduce((sum, rate) => {
+    const qty = quantities[rate.category] ?? 0;
+    return sum + qty * (rate.price ?? 0);
+  }, 0);
+
+  const perPersonInDisplay = selectedReturnOption?.priceAdjustmentByCurrency?.[currency] ?? 0;
+  const returnPriceAdjustment =
+    totalQuantity > 0 && perPersonInDisplay !== 0 ? totalQuantity * perPersonInDisplay : 0;
+
+  const cancellationPolicyFee =
+    cancellationPolicyId && pricingConfig?.cancellationPolicies?.length
+      ? (pricingConfig.cancellationPolicies.find((p) => p.id === cancellationPolicyId)?.feeByCurrency?.[currency] ?? 0)
+      : 0;
+
+  const fees = pricingConfig.fees ?? {};
+  const byCurrency = hasFees ? pricingConfig.feesByCurrency?.[currency] : undefined;
+  const feeLineItems: OrderSummaryFeeLine[] =
+    !hasFees || totalQuantity === 0 || isTaxIncludedInPrice || byCurrency == null
+      ? []
+      : Object.entries(byCurrency).map(([name, amountPerPerson]) => ({
+          name,
+          totalAmount: totalQuantity * amountPerPerson,
+          description: fees[name]?.description,
+        }));
+
+  const feesTotal = feeLineItems.reduce((s, f) => s + f.totalAmount, 0);
+  const subtotal = basePrice + returnPriceAdjustment + cancellationPolicyFee + feesTotal;
+  const tax = isTaxIncludedInPrice ? 0 : subtotal * pricingConfig.taxRate;
+  const total = subtotal + tax;
+
+  const ticketLineItems: OrderSummaryTicketLine[] = pricing
+    .map((rate) => {
+      const qty = quantities[rate.category] ?? 0;
+      if (qty === 0) return null;
+      const pricePerUnit = rate.price ?? 0;
+      return { category: rate.category, qty, pricePerUnit, itemTotal: qty * pricePerUnit };
+    })
+    .filter((line): line is OrderSummaryTicketLine => line != null);
+
+  return {
+    subtotal,
+    tax,
+    total,
+    feeLineItems,
+    returnPriceAdjustment,
+    cancellationPolicyFee,
+    totalQuantity,
+    isTaxIncludedInPrice,
+    ticketLineItems,
+  };
+}

package/src/lib/booking/product-option-id.ts

@@ -0,0 +1,35 @@
+/**
+ * TicketBooth / GYG-style ids: bookings often persist parent product_id (`p_…`) while
+ * availabilities and change sessions use option ids (`po_…`). Match backend semantics:
+ * never use a parent id where an option id is required (e.g. change-booking preselection).
+ */
+
+export function isParentProductId(id: string | null | undefined): boolean {
+  const t = id?.trim();
+  if (!t) return false;
+  return t.startsWith('p_') && !t.startsWith('po_');
+}
+
+/** Returns the id if it is usable as a product option id for matching availabilities; otherwise null. */
+export function normalizeProductOptionIdForChangeFlow(
+  id: string | null | undefined
+): string | null {
+  const t = id?.trim() || null;
+  if (!t || isParentProductId(t)) return null;
+  return t;
+}
+
+/**
+ * Option id to seed change-booking UI: prefer explicit productOptionId, else productId when it is
+ * already an option id (e.g. some payloads).
+ */
+export function effectiveProductOptionIdForChangeFlow(booking: {
+  productId?: string | null;
+  productOptionId?: string | null;
+}): string | null {
+  const fromOption = normalizeProductOptionIdForChangeFlow(booking.productOptionId);
+  if (fromOption) return fromOption;
+  const pid = booking.productId?.trim() || null;
+  if (pid?.startsWith('po_')) return pid;
+  return null;
+}