@ticketboothapp/booking 1.2.103 → 1.2.105

package/src/components/booking/PrivateShuttleBookingFlow.tsx

@@ -130,7 +130,7 @@ function findMergedPrivateShuttleAvailability(
   tz: string
 ): Availability | undefined {
   if (!sel || !optionId || !selectedDateStr) return undefined;
-  const oidMatches = (a: Availability) => (a.productOptionId ?? a.productId) === optionId;
+  const oidMatches = (a: Availability) => getPrivateShuttleAvailabilityOptionId(a) === optionId;
   const availId = sel.availabilityId?.trim();
   if (availId) {
     const hit = merged.find((a) => a.availabilityId === availId && oidMatches(a));
@@ -146,6 +146,40 @@ function findMergedPrivateShuttleAvailability(
   return onDay[0];
 }
 
+function getPrivateShuttleAvailabilityOptionId(availability: Availability): string {
+  const productOptionId = availability.productOptionId?.trim();
+  if (productOptionId) return productOptionId;
+  const productId = availability.productId?.trim();
+  return productId?.startsWith('po_') ? productId : '';
+}
+
+function getPrivateShuttleAvailabilityCacheKey(availability: Availability): string {
+  return `${availability.dateTime}-${getPrivateShuttleAvailabilityOptionId(availability)}`;
+}
+
+function getResourceRate(availability: Availability | undefined | null) {
+  return availability?.rates?.find((r) => r.rateId === 'RESOURCE' || r.category === 'RESOURCE');
+}
+
+function applyResourceAdjustments(
+  basePrice: number,
+  availability: Availability | undefined | null,
+  currency: Currency
+): number {
+  const resourceRate = getResourceRate(availability);
+  const adjustmentTotal =
+    resourceRate?.appliedAdjustments?.reduce(
+      (sum, adjustment) => sum + (adjustment.changeByCurrency?.[currency] ?? 0),
+      0
+    ) ??
+    resourceRate?.applied_adjustments?.reduce(
+      (sum, adjustment) => sum + (adjustment.changeByCurrency?.[currency] ?? 0),
+      0
+    ) ??
+    0;
+  return basePrice + adjustmentTotal;
+}
+
 export function PrivateShuttleBookingFlow({
   product,
   productId,
@@ -394,11 +428,9 @@ export function PrivateShuttleBookingFlow({
 
     let mergedAvailabilities: Availability[] = [];
     setAvailabilities((prev) => {
-      const existingMap = new Map(
-        prev.map((avail) => [`${avail.dateTime}-${avail.productId || avail.productOptionId}`, avail])
-      );
+      const existingMap = new Map(prev.map((avail) => [getPrivateShuttleAvailabilityCacheKey(avail), avail]));
       result.availabilities.forEach((avail) => {
-        existingMap.set(`${avail.dateTime}-${avail.productId || avail.productOptionId}`, avail);
+        existingMap.set(getPrivateShuttleAvailabilityCacheKey(avail), avail);
       });
       mergedAvailabilities = Array.from(existingMap.values());
       return mergedAvailabilities;
@@ -476,11 +508,9 @@ export function PrivateShuttleBookingFlow({
 
     let mergedAvailabilities: Availability[] = [];
     setAvailabilities((prev) => {
-      const existingMap = new Map(
-        prev.map((avail) => [`${avail.dateTime}-${avail.productId || avail.productOptionId}`, avail])
-      );
+      const existingMap = new Map(prev.map((avail) => [getPrivateShuttleAvailabilityCacheKey(avail), avail]));
       result.availabilities.forEach((avail) => {
-        existingMap.set(`${avail.dateTime}-${avail.productId || avail.productOptionId}`, avail);
+        existingMap.set(getPrivateShuttleAvailabilityCacheKey(avail), avail);
       });
       mergedAvailabilities = Array.from(existingMap.values());
       return mergedAvailabilities;
@@ -498,12 +528,12 @@ export function PrivateShuttleBookingFlow({
       const existingCache = availabilitiesCache.get(cacheKey);
       const mergedAvailabilitiesMap = new Map(
         (existingCache?.availabilities ?? []).map((availability) => [
-          `${availability.dateTime}-${availability.productId || availability.productOptionId}`,
+          getPrivateShuttleAvailabilityCacheKey(availability),
           availability,
         ])
       );
       result.availabilities.forEach((availability) => {
-        mergedAvailabilitiesMap.set(`${availability.dateTime}-${availability.productId || availability.productOptionId}`, availability);
+        mergedAvailabilitiesMap.set(getPrivateShuttleAvailabilityCacheKey(availability), availability);
       });
       availabilitiesCache.merge(cacheKey, {
         fetchedRanges: existingCache?.fetchedRanges ?? fetchedRangesRef.current,
@@ -687,13 +717,12 @@ export function PrivateShuttleBookingFlow({
           if (existing.length === 0) return result.availabilities;
           const existingMap = new Map(
             existing.map((avail) => [
-              `${avail.dateTime}-${avail.productId || avail.productOptionId}`,
+              getPrivateShuttleAvailabilityCacheKey(avail),
               avail,
             ])
           );
           result.availabilities.forEach((avail) => {
-            const key = `${avail.dateTime}-${avail.productId || avail.productOptionId}`;
-            existingMap.set(key, avail);
+            existingMap.set(getPrivateShuttleAvailabilityCacheKey(avail), avail);
           });
           return Array.from(existingMap.values());
         })();
@@ -779,9 +808,7 @@ export function PrivateShuttleBookingFlow({
   const optionsAvailableForSelectedDate = useMemo(() => {
     if (!selectedDate) return [];
     const dateAvailabilities = availabilitiesByDate[selectedDate] || [];
-    const optionIds = new Set(
-      dateAvailabilities.map((a) => a.productId || a.productOptionId).filter(Boolean)
-    );
+    const optionIds = new Set(dateAvailabilities.map(getPrivateShuttleAvailabilityOptionId).filter(Boolean));
     return activeOptions.filter((opt) => optionIds.has(opt.optionId));
   }, [selectedDate, availabilitiesByDate, activeOptions]);
 
@@ -819,12 +846,12 @@ export function PrivateShuttleBookingFlow({
         setAvailabilities((prev) => {
           const merged = new Map(
             prev.map((availability) => [
-              `${availability.dateTime}-${availability.productId || availability.productOptionId}`,
+              getPrivateShuttleAvailabilityCacheKey(availability),
               availability,
             ])
           );
           result.availabilities.forEach((availability) => {
-            merged.set(`${availability.dateTime}-${availability.productId || availability.productOptionId}`, availability);
+            merged.set(getPrivateShuttleAvailabilityCacheKey(availability), availability);
           });
           return Array.from(merged.values());
         });
@@ -841,12 +868,12 @@ export function PrivateShuttleBookingFlow({
           const existingCache = availabilitiesCache.get(cacheKey);
           const mergedAvailabilities = new Map(
             (existingCache?.availabilities ?? []).map((availability) => [
-              `${availability.dateTime}-${availability.productId || availability.productOptionId}`,
+              getPrivateShuttleAvailabilityCacheKey(availability),
               availability,
             ])
           );
           result.availabilities.forEach((availability) => {
-            mergedAvailabilities.set(`${availability.dateTime}-${availability.productId || availability.productOptionId}`, availability);
+            mergedAvailabilities.set(getPrivateShuttleAvailabilityCacheKey(availability), availability);
           });
           availabilitiesCache.merge(cacheKey, {
             fetchedRanges: existingCache?.fetchedRanges ?? fetchedRangesRef.current,
@@ -898,22 +925,23 @@ export function PrivateShuttleBookingFlow({
 
   const getOptionPrice = useCallback(
     (optionId: string) => {
+      const opt = activeOptions.find((o) => o.optionId === optionId);
       const dateAvailabilities = selectedDate ? availabilitiesByDate[selectedDate] || [] : [];
       const avail = dateAvailabilities.find(
-        (a) => (a.productId || a.productOptionId) === optionId
+        (a) => getPrivateShuttleAvailabilityOptionId(a) === optionId
       );
+      if (currency === 'CAD' && opt?.pricing?.['RESOURCE'] != null) {
+        return applyResourceAdjustments(opt.pricing['RESOURCE'], avail, currency);
+      }
       if (avail?.rates) {
-        const resourceRate = avail.rates.find(
-          (r) => r.rateId === 'RESOURCE' || r.category === 'RESOURCE'
-        );
+        const resourceRate = getResourceRate(avail);
         if (resourceRate?.priceByCurrency?.[currency] != null)
           return resourceRate.priceByCurrency[currency];
         if (currency === 'CAD' && resourceRate?.price != null) return resourceRate.price;
       }
       if (resourcePriceByOption?.[optionId]?.[currency] != null)
         return resourcePriceByOption[optionId][currency];
-      if (resourcePriceByCurrency?.[currency] != null) return resourcePriceByCurrency[currency];
-      const opt = activeOptions.find((o) => o.optionId === optionId);
+      if (currency === 'CAD' && resourcePriceByCurrency?.[currency] != null) return resourcePriceByCurrency[currency];
       return opt?.pricing?.['RESOURCE'] ?? 0;
     },
     [
@@ -927,10 +955,14 @@ export function PrivateShuttleBookingFlow({
   );
 
   const resourcePrice = useMemo(() => {
-    if (selectedAvailability?.rates) {
-      const resourceRate = selectedAvailability.rates.find(
-        (r) => r.rateId === 'RESOURCE' || r.category === 'RESOURCE'
+    if (currency === 'CAD' && selectedOptionConfig?.pricing?.['RESOURCE'] != null)
+      return applyResourceAdjustments(
+        selectedOptionConfig.pricing['RESOURCE'],
+        selectedAvailability,
+        currency
       );
+    if (selectedAvailability?.rates) {
+      const resourceRate = getResourceRate(selectedAvailability);
       if (resourceRate) {
         const fromRate =
           resourceRate.priceByCurrency?.[currency] ??
@@ -940,10 +972,12 @@ export function PrivateShuttleBookingFlow({
     }
     if (selectedOption && resourcePriceByOption?.[selectedOption]?.[currency] != null)
       return resourcePriceByOption[selectedOption][currency];
-    if (resourcePriceByCurrency?.[currency] != null) return resourcePriceByCurrency[currency];
+    if (currency === 'CAD' && resourcePriceByCurrency?.[currency] != null) return resourcePriceByCurrency[currency];
     if (precomputedPrices?.['RESOURCE']?.[currency] != null)
       return precomputedPrices['RESOURCE'][currency];
-    return selectedOptionConfig?.pricing?.['RESOURCE'] ?? 0;
+    if (selectedOptionConfig?.pricing?.['RESOURCE'] != null)
+      return selectedOptionConfig.pricing['RESOURCE'];
+    return 0;
   }, [
     selectedAvailability,
     resourcePriceByOption,
@@ -1173,7 +1207,7 @@ export function PrivateShuttleBookingFlow({
       setSelectedOption(opt.optionId);
       const dateAvailabilities = availabilitiesByDate[selectedDate] || [];
       const avail = dateAvailabilities.find(
-        (a) => (a.productId || a.productOptionId) === opt.optionId
+        (a) => getPrivateShuttleAvailabilityOptionId(a) === opt.optionId
       );
       setSelectedAvailability(avail || null);
     }
@@ -1231,7 +1265,7 @@ export function PrivateShuttleBookingFlow({
     if (selectedDate) {
       const dateAvailabilities = availabilitiesByDate[selectedDate] || [];
       const avail = dateAvailabilities.find(
-        (a) => (a.productId || a.productOptionId) === optionId
+        (a) => getPrivateShuttleAvailabilityOptionId(a) === optionId
       );
       setSelectedAvailability(avail || null);
     } else {

package/src/contexts/AvailabilitiesCacheContext.tsx

@@ -61,10 +61,12 @@ export function buildAvailabilitiesCacheKey(
   productId: string,
   optionIdsKey: string,
   promoCode: string | null,
-  pricingProfileId?: string | null
+  pricingProfileId?: string | null,
+  cancellationPolicyProfileId?: string | null,
 ): string {
   const pp = (pricingProfileId ?? '').trim();
-  return `${productId}|${optionIdsKey}|${promoCode ?? ''}|pp:${pp}`;
+  const cp = (cancellationPolicyProfileId ?? '').trim();
+  return `${productId}|${optionIdsKey}|${promoCode ?? ''}|pp:${pp}|cp:${cp}`;
 }
 
 export function AvailabilitiesCacheProvider({ children }: { children: ReactNode }) {

package/src/lib/booking/pricing.ts

@@ -331,10 +331,14 @@ export function computePriceBreakdown(
 
   // Subtotal in display currency = base + adjustments; pass so final price is (subtotal + fees) * (1+tax) and breakdown adds up
   const subtotalInDisplayCurrency = baseAmount + adjustmentSum;
+  const backendPriceForDetails =
+    currency === BASE_CURRENCY && subtotalInDisplayCurrency > 0
+      ? subtotalInDisplayCurrency
+      : backendPriceCAD;
   const details = computeTicketPriceDetails(
     pricingConfig,
     currency,
-    backendPriceCAD,
+    backendPriceForDetails,
     hasFees,
     subtotalInDisplayCurrency > 0 ? subtotalInDisplayCurrency : baseInDisplayCurrency
   );

package/src/lib/booking-api.ts

@@ -1623,6 +1623,7 @@ export interface GetAvailabilitiesOptions {
   promoCode?: string | null;
   allOptions?: boolean;
   summary?: boolean;
+  responseMode?: 'summary' | 'booking-day';
   /**
    * When set, TicketBooth should return rates/precomputed prices for this partner pricing profile.
    * Must match the profile linked on the partner (e.g. capabilities.pricingProfileId).
@@ -1670,6 +1671,7 @@ export async function getAvailabilities(
   if (options?.promoCode?.trim()) params.set('promoCode', options.promoCode.trim());
   if (options?.allOptions === true) params.set('allOptions', 'true');
   if (options?.summary === true) params.set('summary', 'true');
+  if (options?.responseMode) params.set('responseMode', options.responseMode);
   const pricingProfileId = options?.pricingProfileId?.trim();
   if (pricingProfileId) params.set('pricingProfileId', pricingProfileId);
   const cancellationPolicyProfileId = options?.cancellationPolicyProfileId?.trim();