spree_cm_commissioner 2.8.3.pre.pre11 → 2.8.3.pre.pre13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc670dfc1c70b1d0307e09941e9e1bbcbcc8b8ebebcd3ff883b81350e42ead04
-  data.tar.gz: 8c1fc869352e101588a38ff8ce00726a50788e7ea9bd936e53d74cf01246ef00
+  metadata.gz: eedbddb863eb9f58dad73a83892a225e971a89736c37af047df757d76bcfc058
+  data.tar.gz: 59eaad5012be611640f1c27f6566bfb91cd7b5cea176d465be69c4230c8b9241
 SHA512:
-  metadata.gz: 696ae98c855011b50c62a2cb60e6f31564d3841531361785595b2334adb340e6f3a189bc73bb3b636801f66664d1bf8037f95bc7ea17895769be09825546e10c
-  data.tar.gz: 641c6beaccb2eb7cc69977d204f583af78d0f49ecd642da05569579a57e96c6e882be53a163ce20cb5d8f0550970bc7998f07b173b6070d20580e9e6ac87ae37
+  metadata.gz: aa9db90a1c39aaa74f66135c5034cb8762e09123edaad154fb5fe6e013609b5344d23910bd8449380030c5b3e391b3a3792c92b569f5fbe2271d6e78420e55e6
+  data.tar.gz: 80c51833f840ba8b4db0611309153c7a7723fd986f065113a06063ac7d5aee78cce2af29dd2eb591b64a90c57a75f1f4716b9d7daf2664903ff34ad031f663e4

data/Gemfile.lock

@@ -34,7 +34,7 @@ GIT
 PATH
   remote: .
   specs:
-    spree_cm_commissioner (2.8.3.pre.pre11)
+    spree_cm_commissioner (2.8.3.pre.pre13)
       activerecord-multi-tenant
       activerecord_json_validator (~> 2.1, >= 2.1.3)
       aws-sdk-cloudfront

data/app/controllers/spree/admin/system/waiting_room_controller.rb

@@ -4,7 +4,10 @@ module Spree
       class WaitingRoomController < Spree::Admin::BaseController
         def show
           @fetcher = SpreeCmCommissioner::WaitingRoomSystemMetadataFetcher.new
+          @lobby_fetcher = SpreeCmCommissioner::WaitingRoomLobbyMetadataFetcher.new
+
           @fetcher.load_document_data
+          @lobby_fetcher.load_document_data
 
           @active_sesions_count = SpreeCmCommissioner::WaitingRoomSession.active.count
         end
@@ -29,6 +32,18 @@ module Spree
 
           redirect_back fallback_location: admin_system_waiting_room_path
         end
+
+        def publish_lobby_path
+          result = SpreeCmCommissioner::WaitingRoom::PublishLobbyPath.call
+
+          if result.success?
+            flash[:success] = "Published waiting guests records path: #{result.value[:records_path]}"
+          else
+            flash[:error] = result.error.to_s
+          end
+
+          redirect_back fallback_location: admin_system_waiting_room_path
+        end
       end
     end
   end

data/app/controllers/spree/api/v2/storefront/transit/draft_orders_controller.rb

@@ -11,6 +11,7 @@ module Spree
             # - inbound_date: Date of inbound transit (optional)
             # - outbound_legs: Array of outbound leg details (required)
             # - inbound_legs: Array of inbound leg details (optional)
+            # - include_return: Whether to add the trip's "return included" add-on as a line item (optional)
             def create
               @outbound_legs = params[:outbound_legs].is_a?(Array) && params[:outbound_legs].any? ? build_legs(:outbound, params[:outbound_legs]) : []
               @inbound_legs  = params[:inbound_legs].is_a?(Array) && params[:inbound_legs].any? ? build_legs(:inbound, params[:inbound_legs]) : []
@@ -20,7 +21,8 @@ module Spree
                 inbound_date: params[:inbound_date]&.to_date,
                 outbound_legs: @outbound_legs,
                 inbound_legs: @inbound_legs,
-                user: spree_current_user
+                user: spree_current_user,
+                include_return: ActiveModel::Type::Boolean.new.cast(params[:include_return])
               )
 
               if result.success?

data/app/controllers/spree/api/v2/tenant/transit/draft_orders_controller.rb

@@ -11,6 +11,7 @@ module Spree
             # - inbound_date: Date of inbound transit (optional)
             # - outbound_legs: Array of outbound leg details (required)
             # - inbound_legs: Array of inbound leg details (optional)
+            # - include_return: Whether to add the trip's "return included" add-on as a line item (optional)
             def create
               @outbound_legs = params[:outbound_legs].is_a?(Array) && params[:outbound_legs].any? ? build_legs(:outbound, params[:outbound_legs]) : []
               @inbound_legs  = params[:inbound_legs].is_a?(Array) && params[:inbound_legs].any? ? build_legs(:inbound, params[:inbound_legs]) : []
@@ -20,7 +21,8 @@ module Spree
                 inbound_date: params[:inbound_date]&.to_date,
                 outbound_legs: @outbound_legs,
                 inbound_legs: @inbound_legs,
-                user: spree_current_user
+                user: spree_current_user,
+                include_return: ActiveModel::Type::Boolean.new.cast(params[:include_return])
               )
 
               if result.success?

data/app/interactors/spree_cm_commissioner/pin_code_sender.rb

@@ -6,7 +6,7 @@ module  SpreeCmCommissioner
       context.fail!(message: I18n.t('pincode_sender.pincode.blank')) if context.pin_code.nil?
 
       if context.pin_code.phone_number?
-        send_sms
+        send_phone_otp
       else
         send_email
       end
@@ -16,18 +16,73 @@ module  SpreeCmCommissioner
 
     private
 
-    def send_sms
+    # Channel selection for phone-number OTPs lives here so the routing is
+    # easy to find and reason about. Telegram Gateway is primary; SMS is the fallback.
+    def send_phone_otp
+      if telegram_gateway_available?
+        send_via_telegram_gateway
+      else
+        send_via_sms
+      end
+    end
+
+    def telegram_gateway_available?
+      return false unless telegram_gateway_enabled?
+      return false if telegram_gateway_api_key.blank?
+
+      ability = telegram_gateway_adapter.check_send_ability(context.pin_code.contact)
+      context.telegram_gateway_request_id = ability.request_id if ability.ok?
+      ability.ok?
+    rescue TelegramGatewayAdapter::Error, Faraday::Error
+      false
+    end
+
+    def send_via_telegram_gateway
       from_number = sms_from_number
       return if from_number.blank?
 
-      options = {
+      # Save the chosen channel + the Telegram request_id synchronously so
+      # (a) the API response already reflects the channel for the mobile UI,
+      # (b) verification can reach Telegram even if the user submits the OTP
+      #     before the async send job has run. For Telegram-delivered codes
+      #     the `code` column stores Telegram's request_id (Telegram generates
+      #     and holds the actual OTP).
+      context.pin_code.update!(
+        delivery_channel: :telegram_gateway,
+        code: context.telegram_gateway_request_id
+      )
+
+      SpreeCmCommissioner::TelegramGateway::PinCodeSenderJob.perform_later(
+        pin_code_id: context.pin_code.id,
+        from: from_number,
+        request_id: context.telegram_gateway_request_id,
+        tenant_id: context.pin_code&.application&.tenant_id
+      )
+    end
+
+    def send_via_sms
+      from_number = sms_from_number
+      return if from_number.blank?
+
+      SpreeCmCommissioner::SmsPinCodeJob.perform_later(
+        pin_code_id: context.pin_code.id,
         from: from_number,
         to: context.pin_code.contact,
         body: I18n.t('pincode_sender.sms.body', code: context.pin_code.code, readable_type: context.pin_code.readable_type),
         tenant_id: context.pin_code&.application&.tenant_id
-      }
+      )
+    end
+
+    def telegram_gateway_enabled?
+      ENV['TELEGRAM_GATEWAY_ENABLED'] == 'yes'
+    end
 
-      SpreeCmCommissioner::SmsPinCodeJob.perform_later(options)
+    def telegram_gateway_api_key
+      @telegram_gateway_api_key ||= ENV.fetch('TELEGRAM_GATEWAY_API_KEY', nil)
+    end
+
+    def telegram_gateway_adapter
+      @telegram_gateway_adapter ||= TelegramGatewayAdapter::Client.new
     end
 
     def sms_from_number
@@ -38,6 +93,8 @@ module  SpreeCmCommissioner
     end
 
     def send_email
+      context.pin_code.update!(delivery_channel: :email)
+
       SpreeCmCommissioner::PinCodeMailer.send_pin_code(
         context.pin_code.id,
         context.pin_code.readable_type,

data/app/interactors/spree_cm_commissioner/waiting_guests_caller.rb

@@ -19,18 +19,47 @@ module SpreeCmCommissioner
       max_sessions - active_sessions
     end
 
-    # This query required index. create them in Firebase beforehand.
-    # Client side must create waiting_guests document with :queued_at & :allow_to_enter_room_at to null to allow fillter & order.
+    # This query requires an index; create it in Firebase beforehand.
+    # Client must create waiting_guests documents with :queued_at and :allow_to_enter_room_at set to nil to allow filter + order queries.
+    #
+    # Yesterday's guests are always older than today's, so fill from yesterday first, then use any
+    # leftover slots for today. This way no one queued before the midnight rollover gets skipped.
+    #   e.g. 5 slots, 2 waiting in yesterday -> take both, then take 3 from today.
     def fetch_long_waiting_guests(available_slots)
-      firestore.col('waiting_guests')
-               .doc(current_date)
-               .col('records')
+      previous_guests = eligible_guests_in(previous_records_path, available_slots)
+
+      # Pre-flip window: the lobby pointer still points at yesterday, so both paths resolve to the
+      # same partition — return now to avoid querying (and double-counting) it twice.
+      return previous_guests if records_path == previous_records_path
+
+      remaining_slots = available_slots - previous_guests.size
+      return previous_guests if remaining_slots <= 0
+
+      previous_guests + eligible_guests_in(records_path, remaining_slots)
+    end
+
+    def eligible_guests_in(records_path, limit)
+      firestore.col(records_path)
                .where('allow_to_enter_room_at', '==', nil)
                .order('queued_at')
-               .limit(available_slots)
+               .limit(limit)
                .get.to_a
     end
 
+    # Published path is authoritative; fall back to the server's own date if not yet published.
+    def records_path
+      lobby_data&.dig(:waiting_guests_records_path).presence || default_records_path(current_date)
+    end
+
+    # Drain target is derived from the server date, never the (possibly stale) lobby pointer.
+    def previous_records_path
+      default_records_path(previous_date)
+    end
+
+    def default_records_path(date)
+      "waiting_guests/#{date}/records"
+    end
+
     # For alert waiting guests to enter room, we just update :allow_to_enter_room_at.
     # App will listen to firebase & start refresh session token to enter room.
     def calling_all(waiting_guests)
@@ -45,9 +74,22 @@ module SpreeCmCommissioner
       Time.zone.now.strftime('%Y-%m-%d')
     end
 
+    def previous_date
+      1.day.ago.strftime('%Y-%m-%d')
+    end
+
     # When open app, app request to check whether room is full or not via Firebase instead of server to minimize server requests.
+    # merge: true so we preserve the published `waiting_guests_records_path` on the lobby doc.
     def mark_as(full:, available_slots:)
-      firestore.col('waiting_rooms').doc('lobby').set({ full: full, available_slots: available_slots })
+      lobby_document.set({ full: full, available_slots: available_slots }, merge: true)
+    end
+
+    def lobby_data
+      @lobby_data ||= lobby_document.get.data
+    end
+
+    def lobby_document
+      @lobby_document ||= firestore.col('waiting_rooms').doc('lobby')
     end
 
     def fetch_max_sessions

data/app/jobs/spree_cm_commissioner/telegram_gateway/pin_code_sender_job.rb

@@ -0,0 +1,18 @@
+module SpreeCmCommissioner
+  module TelegramGateway
+    # options = { pin_code_id:, from:, request_id:, tenant_id: }
+    class PinCodeSenderJob < SpreeCmCommissioner::SmsJob
+      def perform(options = {})
+        pin_code = SpreeCmCommissioner::PinCode.find_by(id: options[:pin_code_id])
+        return if pin_code.nil?
+
+        SpreeCmCommissioner::TelegramGateway::PinCodeSender.call(
+          pin_code: pin_code,
+          from: options[:from],
+          request_id: options[:request_id],
+          tenant_id: options[:tenant_id]
+        )
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/waiting_room/publish_lobby_path_job.rb

@@ -0,0 +1,17 @@
+# waiting_room_lobby_path_publisher:
+#   cron: "0 0 * * * Asia/Phnom_Penh" # Once per day at local midnight (date rollover)
+#   class: "SpreeCmCommissioner::WaitingRoom::PublishLobbyPathJob"
+module SpreeCmCommissioner
+  module WaitingRoom
+    class PublishLobbyPathJob < ApplicationJob
+      queue_as :waiting_room
+
+      def perform
+        return if ENV['WAITING_ROOM_DISABLED'] == 'yes'
+
+        # call! so a publish failure raises (Sidekiq retries/alerts) instead of being silently swallowed.
+        SpreeCmCommissioner::WaitingRoom::PublishLobbyPath.call!
+      end
+    end
+  end
+end

data/app/models/concerns/spree_cm_commissioner/line_item_open_dated_trippable.rb

@@ -1,13 +1,28 @@
 module SpreeCmCommissioner
+  # Makes an open-return entitlement line item redeemable.
+  #
+  # New design: the open return is no longer a fake open-dated *trip* line item. It is a plain
+  # ecommerce add-on (a Spree::Product linked to the outbound trip's product via an
+  # `open_dated_pair` ProductRelation) sold as a regular ecommerce line item at checkout.
+  #
+  # Redemption swaps that ecommerce line item in place into a concrete transit ticket on a chosen
+  # return trip (see SpreeCmCommissioner::OpenDatedTrips::Redeem). Once swapped, the line item is a
+  # `transit` item.
   module LineItemOpenDatedTrippable
     extend ActiveSupport::Concern
 
     included do
       include SpreeCmCommissioner::StoreMetadata
 
-      # Open dated trip metadata
-      store_public_metadata :is_open_dated, :boolean, default: false
-      store_public_metadata :original_trip_id, :integer # Original template trip ID BEFORE redemption
+      store_private_metadata :open_dated_product_id, :integer
+
+      # The endpoints (Place ids) the *return* trip must run between — already reversed from the
+      # outbound journey at purchase time (return origin = outbound destination, and vice versa).
+      # Storing the return direction means every consumer reads it directly: redemption is a plain
+      # id match and the search needs no flip. Endpoints rather than a trip keep this
+      # leg-count-independent: a multi-leg outbound still has exactly one origin and one destination.
+      store_private_metadata :open_dated_return_origin_place_id, :integer
+      store_private_metadata :open_dated_return_destination_place_id, :integer
 
       # Alias existing columns for better semantic meaning
       alias_attribute :valid_until, :to_date        # Expiration date
@@ -19,19 +34,47 @@ module SpreeCmCommissioner
       accepter
     end
 
-    # Check if ticket has been redeemed
+    def open_dated?
+      open_dated_return_origin_place_id.present? && open_dated_return_destination_place_id.present?
+    end
+
+    def open_dated_product
+      return nil if open_dated_product_id.blank?
+
+      @open_dated_product ||= Spree::Product.find_by(id: open_dated_product_id)
+    end
+
+    # Origin place the return trip must depart from (= outbound destination).
+    def open_dated_return_origin_place
+      return nil if open_dated_return_origin_place_id.blank?
+
+      @open_dated_return_origin_place ||= SpreeCmCommissioner::Place.find_by(id: open_dated_return_origin_place_id)
+    end
+
+    # Destination place the return trip must arrive at (= outbound origin).
+    def open_dated_return_destination_place
+      return nil if open_dated_return_destination_place_id.blank?
+
+      @open_dated_return_destination_place ||= SpreeCmCommissioner::Place.find_by(id: open_dated_return_destination_place_id)
+    end
+
+    # Human-readable return journey, e.g. "Siem Reap → Phnom Penh". Nil when endpoints are missing.
+    def open_dated_route_label
+      return nil if open_dated_return_origin_place.blank? || open_dated_return_destination_place.blank?
+
+      "#{open_dated_return_origin_place.full_path_name} → #{open_dated_return_destination_place.full_path_name}"
+    end
+
     def redeemed?
       redeemed_at.present?
     end
 
-    # Check if ticket is expired
     def expired?
       valid_until.present? && valid_until.to_date < Date.current
     end
 
-    # Check if ticket can be redeemed
     def can_redeem?
-      is_open_dated? && !redeemed? && !expired?
+      open_dated? && !redeemed? && !expired?
     end
   end
 end

data/app/models/concerns/spree_cm_commissioner/line_item_transitable.rb

@@ -138,7 +138,6 @@ module SpreeCmCommissioner
 
       trip = SpreeCmCommissioner::Trip.find_by(id: trip_id)
       return unless trip # Skip if trip doesn't exist (will be caught by other validations)
-      return if trip.open_dated? # Skip validation for open-dated trips
 
       # For scheduled trips, require valid trip stops
       errors.add(:boarding_trip_stop_id, 'must be greater than 0') if boarding_trip_stop_id.present? && boarding_trip_stop_id <= 0

data/app/models/spree_cm_commissioner/pin_code.rb

@@ -3,8 +3,9 @@ module SpreeCmCommissioner
     has_secure_token
 
     enum contact_type: { 'phone_number' => 0, 'email' => 1, 'telegram' => 2 }
+    enum delivery_channel: { sms: 0, telegram_gateway: 1, email: 2 }, _prefix: :delivered_via
 
-    validates :code, length: { maximum: 6 }
+    validates :code, length: { maximum: 32 }
     validates :contact, presence: true
     validates :contact, email: true, if: :email?
     validates :type, presence: true
@@ -18,6 +19,15 @@ module SpreeCmCommissioner
     PIN_CODE_MISMATCHED = 'not_match'.freeze
     PIN_CODE_OK = 'ok'.freeze
 
+    # Maps Telegram Gateway verification_status values to our PIN_CODE_* results.
+    # Anything not in this map → soft fallback to local comparison.
+    TELEGRAM_VERIFICATION_RESULTS = {
+      'code_valid' => PIN_CODE_OK,
+      'code_invalid' => PIN_CODE_MISMATCHED,
+      'code_max_attempts_exceeded' => PIN_CODE_ATTEMPT_REACHED,
+      'expired' => PIN_CODE_EXPIRED
+    }.freeze
+
     belongs_to :application, class_name: 'Spree::OauthApplication', optional: true
 
     def check?(code)
@@ -26,14 +36,10 @@ module SpreeCmCommissioner
 
       increment_attempt
 
-      if self.code == code
-        set_expire
-        save
-        PIN_CODE_OK
-      else
-        save
-        PIN_CODE_MISMATCHED
-      end
+      result = verify_code(code)
+      set_expire if result == PIN_CODE_OK
+      save
+      result
     end
 
     def set_expire
@@ -143,5 +149,52 @@ module SpreeCmCommissioner
       self.code = Random.new.bytes(8).bytes.join[0, 6]
       self.expires_in = expires_in_seconds
     end
+
+    # SMS codes verify internally (Plasgate has no verify API).
+    # Telegram-delivered codes verify with Telegram — no internal fallback,
+    # because `code` holds Telegram's request_id, not a comparable OTP.
+    # If Telegram is unreachable, we return PIN_CODE_MISMATCHED; the user
+    # retries from the app.
+    def verify_code(submitted_code)
+      return verify_internally(submitted_code) unless delivered_via_telegram_gateway?
+
+      verify_with_telegram(submitted_code) || PIN_CODE_MISMATCHED
+    end
+
+    def verify_internally(submitted_code)
+      code == submitted_code ? PIN_CODE_OK : PIN_CODE_MISMATCHED
+    end
+
+    # For Telegram-delivered PinCodes, `code` column stores Telegram's
+    # request_id (not the OTP itself — Telegram generated and delivered the OTP).
+    # Returns a PIN_CODE_* result, or nil if Telegram couldn't help us decide
+    # (network error, unmapped status).
+    def verify_with_telegram(submitted_code)
+      result = TelegramGatewayAdapter::Client.new.check_verification_status(code, submitted_code)
+      TELEGRAM_VERIFICATION_RESULTS[result.verification_status]
+    rescue TelegramGatewayAdapter::Error, Faraday::Error => e
+      log_verification_error(e)
+      nil
+    end
+
+    def log_verification_error(error)
+      CmAppLogger.error(
+        label: 'PinCode#verify_with_telegram failed',
+        data: {
+          pin_code_id: id,
+          request_id: code,
+          error_class: error.class.name,
+          error_message: error.message
+        }
+      )
+
+      return unless ENV['PIN_CODE_DEBUG_NOTIFIY_TELEGRAM_ENABLE'] == 'yes'
+
+      SpreeCmCommissioner::TelegramDebugPinCodeSenderJob.perform_later(
+        pin_code_id: id,
+        tenant_id: application&.tenant_id,
+        error_message: "Verification failed: #{error.class.name} — #{error.message}"
+      )
+    end
   end
 end

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -55,6 +55,12 @@ module SpreeCmCommissioner
       base.has_many :product_relations, class_name: 'SpreeCmCommissioner::ProductRelation', dependent: :destroy
       base.has_many :related_products, through: :product_relations
 
+      # Inverse side of product_relations: relations where this product is the related_product
+      # (e.g. trip add-ons point here).
+      base.has_many :inverse_product_relations, class_name: 'SpreeCmCommissioner::ProductRelation',
+                                                foreign_key: :related_product_id,
+                                                dependent: :destroy
+
       base.belongs_to :event, class_name: 'Spree::Taxon', optional: true
 
       base.has_many :preview_roles, class_name: 'SpreeCmCommissioner::PreviewRole', as: :previewable

data/app/models/spree_cm_commissioner/show.rb

@@ -81,10 +81,6 @@ module SpreeCmCommissioner
                    :block_vpn,
                    :max_votes_per_contestant_per_user
 
-    def parent_slug
-      parent&.slug
-    end
-
     def show?
       depth == 1
     end

data/app/models/spree_cm_commissioner/trip.rb

@@ -65,9 +65,8 @@ module SpreeCmCommissioner
     has_many :inventory_items, through: :variants
     has_many :blocks, through: :variants
 
-    validates :departure_time, presence: true, unless: :open_dated?
-    validates :vehicle_type, presence: true, unless: :open_dated?
-    validates :duration, numericality: { greater_than: 0 }, unless: :open_dated?
+    validates :departure_time, presence: true
+    validates :duration, numericality: { greater_than: 0 }
 
     validate :direct_trips_cannot_have_board_to_trips, if: -> { direct? }
     validate :multi_leg_trip_stops_must_have_board_to_trip, if: -> { multi_leg? }
@@ -120,15 +119,6 @@ module SpreeCmCommissioner
       errors.add(:board_to_trips, 'direct trips cannot have board_to_trips')
     end
 
-    def open_dated?
-      is_open_dated == true
-    end
-
-    # Find the open dated version of this trip's product
-    def open_dated_pair
-      open_dated_product
-    end
-
     def display_name
       product&.name
     end

data/app/models/spree_cm_commissioner/voting_contestant.rb

@@ -8,7 +8,6 @@ module SpreeCmCommissioner
     belongs_to :advanced_to, polymorphic: true, optional: true
     belongs_to :advanced_from, polymorphic: true, optional: true
     has_many :votes, class_name: 'SpreeCmCommissioner::Vote', foreign_key: :contestant_id, dependent: :restrict_with_error
-    has_one :leading_stat, class_name: 'SpreeCmCommissioner::VotingSessionStat', foreign_key: :leading_contestant_id, dependent: :nullify
     has_many :show_contestant_images, through: :show_contestant
     has_many :show_contestant_videos, through: :show_contestant
 

data/app/queries/spree_cm_commissioner/single_leg_trips_query.rb

@@ -14,7 +14,7 @@
 #   results = query.call  # => [TripQueryResult, ...]
 #
 module SpreeCmCommissioner
-  class SingleLegTripsQuery
+  class SingleLegTripsQuery # rubocop:disable Metrics/ClassLength
     attr_reader :origin_id, :destination_id, :date,
                 :vendor_id, :tenant_id,
                 :number_of_guests, :route_type, :options
@@ -61,8 +61,7 @@ module SpreeCmCommissioner
         .eager_load(
           vendor: :logo,
           vehicle_type: :option_values,
-          route: {},
-          open_dated_product: %i[trip variants]
+          route: {}
         )
         .select(selected_columns_sql)
         .joins(
@@ -79,6 +78,7 @@ module SpreeCmCommissioner
             LEFT JOIN spree_prices AS date_prices ON date_prices.inventory_item_id = date_iv.id AND date_prices.deleted_at IS NULL
             LEFT JOIN (#{stops_subquery_sql}) all_stops ON all_stops.trip_id = cm_trips.id
             #{return_metric_joins_sql}
+            #{open_dated_product_joins_sql}
           SQL
         )
         .where(<<~SQL.squish, origin: origin_id, destination: destination_id)
@@ -111,6 +111,9 @@ module SpreeCmCommissioner
         COALESCE(date_prices.compare_at_amount, prices.compare_at_amount) AS compare_at_price,
         COALESCE(date_prices.currency, prices.currency) AS currency,
         all_stops.stops AS stops,
+        open_dated_rel.product_id AS open_dated_product_id,
+        open_dated_prices.amount AS open_dated_price,
+        open_dated_prices.compare_at_amount AS open_dated_compare_at_price,
         #{return_columns_sql}
       SQL
     end
@@ -142,6 +145,24 @@ module SpreeCmCommissioner
       SQL
     end
 
+    # Joins the "open dated" pair product (if any) for the trip's product, and its master price,
+    # so we can expose the return add-on's price/compare_at_price without loading the full
+    # Spree::Product/Variant/Price records.
+    def open_dated_product_joins_sql
+      <<~SQL.squish
+        LEFT JOIN cm_product_relations AS open_dated_rel
+          ON open_dated_rel.related_product_id = cm_trips.product_id
+         AND open_dated_rel.relation_type = #{SpreeCmCommissioner::ProductRelation.relation_types[:open_dated_pair]}
+        LEFT JOIN spree_variants AS open_dated_master
+          ON open_dated_master.product_id = open_dated_rel.product_id
+         AND open_dated_master.is_master = true
+        LEFT JOIN spree_prices AS open_dated_prices
+          ON open_dated_prices.variant_id = open_dated_master.id
+         AND open_dated_prices.inventory_item_id IS NULL
+         AND open_dated_prices.deleted_at IS NULL
+      SQL
+    end
+
     # Subquery to aggregate all stops for each trip into a JSON array, ordered by sequence.
     # Each stop includes place coordinates (lat/lon) joined from cm_places.
     # Returns one row per trip_id with a `stops` JSON column consumed by selected_columns_sql.

data/app/serializers/spree/v2/storefront/product_serializer_decorator.rb

@@ -14,7 +14,9 @@ module Spree
 
           base.attributes :need_confirmation, :product_type, :kyc, :kyc_fields, :allowed_upload_later, :allow_anonymous_booking,
                           :use_video_as_default, :allow_transfer, :allow_gift_transfer
-          base.attributes :reveal_description, :discontinue_on, :public_metadata, :purchasable_on, :preview
+
+          base.attributes :reveal_description, :discontinue_on, :public_metadata, :purchasable_on, :preview,
+                          :enable_inventory_hold
 
           # Expose only the `event_id` here instead of the full event object.
           # This lets the client fetch event details separately (usually already cached),

data/app/serializers/spree/v2/tenant/show_episode_serializer.rb

@@ -2,7 +2,7 @@ module Spree
   module V2
     module Tenant
       class ShowEpisodeSerializer < BaseSerializer
-        attributes :episode_number, :name, :description, :scheduled_at, :ends_at
+        attributes :episode_number, :name, :scheduled_at, :ends_at
 
         attribute :status do |episode|
           if episode.current?

data/app/serializers/spree/v2/tenant/show_serializer.rb

@@ -5,11 +5,10 @@ module Spree
         set_type :show
 
         attributes :slug, :description, :permalink, :from_date, :to_date, :preview, :created_at, :updated_at,
-                   :free_vote_limit, :free_vote_limit_type, :show_type, :parent_slug
+                   :free_vote_limit, :free_vote_limit_type, :show_type
 
         attribute :name, &:display_name
 
-        has_many :seasons, serializer: Spree::V2::Tenant::ShowSerializer
         has_many :show_people, serializer: Spree::V2::Tenant::ShowPersonSerializer
         has_many :episodes, serializer: Spree::V2::Tenant::ShowEpisodeSerializer
         has_many :voting_sessions, serializer: Spree::V2::Tenant::VotingSessionSerializer

data/app/serializers/spree_cm_commissioner/v2/storefront/pin_code_serializer.rb

@@ -4,7 +4,7 @@ module SpreeCmCommissioner
       class PinCodeSerializer < BaseSerializer
         set_type :pin_code
 
-        attribute :token, :type, :contact_type, :contact
+        attribute :token, :type, :contact_type, :contact, :delivery_channel
       end
     end
   end