spree_cm_commissioner 2.9.2 → 2.9.4

data/app/models/spree_cm_commissioner/user_decorator.rb

@@ -52,7 +52,6 @@ module SpreeCmCommissioner
       base.scope :by_non_tenant, -> { where(tenant_id: nil) }
       base.scope :vendor_users, -> (vendor_id) { joins(:role_users => :role).where(spree_roles: { vendor_id: vendor_id }).distinct }
 
-      base.store :public_metadata, accessors: [:has_incomplete_guest_info], coder: JSON
       base.store :private_metadata, accessors: %i[otp_secret otp_required_for_login consumed_timestep], coder: JSON
 
       base.store_public_metadata :primary_service_type, :string
@@ -66,6 +65,15 @@ module SpreeCmCommissioner
       # the id_token param. Nothing token-related is stored on the account itself.
       base.store_private_metadata :load_test_account, :boolean, default: false
 
+      # SQL counterpart of `load_test_account?`, so the flag can be filtered in the DB instead of
+      # loading rows into Ruby to call the predicate. private_metadata is stored double-encoded (a
+      # JSON string scalar, not a native jsonb object — see store_metadata), so unwrap the outer
+      # string with `#>> '{}'` before keying into it. Keeps the storage detail in one place next to
+      # the declaration above rather than duplicating the raw SQL in every caller.
+      base.scope :load_test_accounts, lambda {
+        where("(private_metadata #>> '{}')::jsonb ->> 'load_test_account' = 'true'")
+      }
+
       # Validations
       base.validates :primary_service_type,
                      inclusion: { in: SpreeCmCommissioner::ServiceType::SERVICE_TYPES.map(&:to_s) },
@@ -223,6 +231,23 @@ module SpreeCmCommissioner
         super(request)
       end
     end
+
+    def has_incomplete_guest_info? # rubocop:disable Naming/PredicateName
+      # expires_in is a safety net, not the primary invalidation path — see the matching comment
+      # on Order#has_incomplete_guest_info?. Joins straight to guests.post_registration instead of
+      # calling Order#has_incomplete_guest_info? per order (which would be N+1 query calls).
+      Rails.cache.fetch(incomplete_guest_info_cache_key, expires_in: 1.hour) do
+        orders.complete.joins(:guests).merge(SpreeCmCommissioner::Guest.post_registration).exists?
+      end
+    end
+
+    def clear_has_incomplete_guest_info_cache
+      Rails.cache.delete(incomplete_guest_info_cache_key)
+    end
+
+    def incomplete_guest_info_cache_key
+      "user/#{id}/has_incomplete_guest_info"
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/voting_contestant.rb

@@ -5,6 +5,7 @@ module SpreeCmCommissioner
     belongs_to :show, class_name: 'Spree::Taxon', optional: false
     belongs_to :voting_session, class_name: 'SpreeCmCommissioner::VotingSession', optional: false
     belongs_to :show_contestant, class_name: 'SpreeCmCommissioner::ShowContestant', optional: false
+    belongs_to :advanced_to_episode, class_name: 'SpreeCmCommissioner::ShowEpisode', optional: true
     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
@@ -37,6 +38,7 @@ module SpreeCmCommissioner
     # | 1             | 1         | 2           | ✓ OK   | Can update/change number  |
     # | 1             | 2         | 1           | ✓ OK   | Different session         |
     validates :vote_number, uniqueness: { scope: :voting_session_id, allow_nil: true }
+    validate :advanced_to_and_advanced_from_must_differ
 
     delegate :name, :contestant_number, :category, :gender, :eliminated_at, to: :show_contestant, allow_nil: true
     delegate :can_vote?, to: :voting_session, allow_nil: true
@@ -50,11 +52,11 @@ module SpreeCmCommissioner
     end
 
     def advanced_from_name
-      advanced_from&.name
+      [advanced_from&.episode&.name, advanced_from&.name].compact.join(' - ')
     end
 
     def advanced_to_name
-      advanced_to&.name
+      [advanced_to&.episode&.name || advanced_to_episode&.name, advanced_to&.name].compact.join(' - ')
     end
 
     private
@@ -97,5 +99,14 @@ module SpreeCmCommissioner
       errors.add(:base, :has_advanced_to_session)
       throw :abort
     end
+
+    # Prevent a contestant from being advanced to the same record it was advanced from,
+    # which would create a self-referencing loop between sessions.
+    def advanced_to_and_advanced_from_must_differ
+      return if advanced_to_id.blank? || advanced_from_id.blank?
+      return unless advanced_to_type == advanced_from_type && advanced_to_id == advanced_from_id
+
+      errors.add(:advanced_to_id, :same_as_advanced_from)
+    end
   end
 end

data/app/queries/spree_cm_commissioner/event_chart_queries.rb

@@ -59,7 +59,7 @@ module SpreeCmCommissioner
                WHEN cm_check_ins.id IS NOT NULL THEN 'show'
                ELSE 'no_show'
              END AS name,
-             COUNT(*) AS total"
+             COUNT(DISTINCT cm_guests.id) AS total"
                             )
                      .group('spree_products.id, CASE WHEN cm_check_ins.id IS NOT NULL THEN \'show\' ELSE \'no_show\' END')
                      .group_by(&:product_id)
@@ -98,7 +98,7 @@ module SpreeCmCommissioner
              WHEN cm_check_ins.entry_type = 0 THEN 'normal'
              WHEN cm_check_ins.entry_type = 1 THEN 'VIP'
            END AS name,
-           COUNT(cm_check_ins.id) AS total"
+           COUNT(DISTINCT cm_guests.id) AS total"
              )
              .group('spree_products.id, cm_check_ins.entry_type')
              .group_by(&:product_id)

data/app/queries/spree_cm_commissioner/pie_chart_event_aggregator_queries.rb

@@ -58,7 +58,7 @@ module SpreeCmCommissioner
                    WHEN cm_check_ins.id IS NOT NULL THEN 'show'
                    ELSE 'no_show'
                  END AS name,
-                 COUNT(*) AS total"
+                 COUNT(DISTINCT cm_guests.id) AS total"
                )
         .group('spree_products.id, CASE WHEN cm_check_ins.id IS NOT NULL THEN \'show\' ELSE \'no_show\' END')
         .group_by(&:product_id)
@@ -110,7 +110,7 @@ module SpreeCmCommissioner
                   CASE  WHEN cm_check_ins.entry_type = 0 THEN 'normal'
                         WHEN cm_check_ins.entry_type = 1 THEN 'VIP'
                         ELSE NULL END AS name,
-                  COUNT(cm_check_ins.id) AS total"
+                  COUNT(DISTINCT cm_guests.id) AS total"
                )
         .where.not(cm_check_ins: { id: nil })
         .group('spree_products.id, cm_check_ins.entry_type')

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

@@ -35,11 +35,11 @@ module Spree
 
           base.has_one :google_wallet, serializer: SpreeCmCommissioner::V2::Storefront::GoogleWalletSerializer
 
-          base.has_many :guests, serializer: SpreeCmCommissioner::V2::Storefront::GuestMinimalSerializer
+          base.has_many :guests, serializer: SpreeCmCommissioner::V2::Storefront::GuestSerializer
 
           base.has_many :saved_guests, serializer: SpreeCmCommissioner::V2::Storefront::SavedGuestSerializer
 
-          base.has_many :pending_guests, serializer: SpreeCmCommissioner::V2::Storefront::GuestMinimalSerializer
+          base.has_many :pending_guests, serializer: SpreeCmCommissioner::V2::Storefront::GuestSerializer
 
           base.has_one :product, serializer: Spree::V2::Storefront::ProductSerializer
 

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

@@ -5,10 +5,12 @@ module Spree
         def self.prepended(base)
           base.attributes :first_name, :last_name, :gender, :phone_number, :intel_phone_number,
                           :country_code, :otp_enabled, :otp_email, :otp_phone_number,
-                          :confirm_pin_code_enabled, :tenant_id, :has_incomplete_guest_info,
+                          :confirm_pin_code_enabled, :tenant_id,
                           :login, :qr_data, :qr_data_version, :qr_data_invalidated_at,
                           :unread_notifications_count, :request_orders_count
 
+          base.attribute :has_incomplete_guest_info, &:has_incomplete_guest_info?
+
           base.has_one :profile, serializer: ::Spree::V2::Storefront::UserProfileSerializer
           base.has_many :device_tokens, serializer: Spree::V2::Storefront::UserDeviceTokenSerializer
           base.has_many :spree_roles, serializer: Spree::V2::Storefront::RoleSerializer

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

@@ -0,0 +1,23 @@
+module Spree
+  module V2
+    module Tenant
+      class SavedGuestSerializer < BaseSerializer
+        attributes :first_name,
+                   :last_name,
+                   :dob,
+                   :age,
+                   :gender,
+                   :email,
+                   :country_code,
+                   :phone_number,
+                   :intel_phone_number,
+                   :user_id,
+                   :age_group,
+                   :nationality_group
+
+        belongs_to :occupation, serializer: Spree::V2::Tenant::TaxonSerializer
+        belongs_to :nationality, serializer: Spree::V2::Tenant::TaxonSerializer
+      end
+    end
+  end
+end

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

@@ -11,6 +11,7 @@ module SpreeCmCommissioner
                           :term_accepted_at,
                           :channel, :hold_expires_at
 
+          base.attribute :has_incomplete_guest_info, &:has_incomplete_guest_info?
           base.attribute :qr_data do |order|
             order.qr_data if order.completed?
           end

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

@@ -7,13 +7,10 @@ module SpreeCmCommissioner
         attributes :first_name, :last_name, :dob, :gender, :kyc_fields, :other_occupation, :created_at, :updated_at,
                    :qr_data, :social_contact_platform, :social_contact, :available_social_contact_platforms,
                    :age, :emergency_contact, :other_organization, :expectation, :upload_later, :address, :formatted_bib_number, :phone_number,
-                   :token, :country_code, :contact, :data_fill_stage_phase,
+                   :token, :country_code, :contact, :seat_number,
                    :saved_guest_id, :state
 
-        # temporary, once app release after cm-app v1.9.1, we no longer need this.
-        attribute :seat_number do |object|
-          object.seat_number || object.formatted_bib_number
-        end
+        attribute :data_fill_stage_phase, &:data_fill_stage
 
         attribute :allowed_checkout, &:allowed_checkout?
         attribute :allowed_upload_later, &:allowed_upload_later?
@@ -30,7 +27,7 @@ module SpreeCmCommissioner
 
         has_many :check_ins, serializer: SpreeCmCommissioner::V2::Storefront::CheckInSerializer
 
-        has_many :ticket_transfers, serializer: SpreeCmCommissioner::V2::Storefront::TicketTransferMinimalSerializer
+        has_many :ticket_transfers, serializer: SpreeCmCommissioner::V2::Storefront::TicketTransferSerializer
 
         # allowed_checkout updates frequently
         cache_options store: nil

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

@@ -9,8 +9,8 @@ module SpreeCmCommissioner
 
         belongs_to :from_user, serializer: ::Spree::V2::Storefront::UserSerializer
         belongs_to :to_user, serializer: ::Spree::V2::Storefront::UserSerializer
-        belongs_to :from_guest, serializer: SpreeCmCommissioner::V2::Storefront::GuestMinimalSerializer
-        belongs_to :to_guest, serializer: SpreeCmCommissioner::V2::Storefront::GuestMinimalSerializer
+        belongs_to :from_guest, serializer: SpreeCmCommissioner::V2::Storefront::GuestSerializer
+        belongs_to :to_guest, serializer: SpreeCmCommissioner::V2::Storefront::GuestSerializer
         belongs_to :event, serializer: Spree::V2::Storefront::TaxonSerializer
         belongs_to :product, serializer: Spree::V2::Storefront::ProductSerializer
         belongs_to :order, serializer: ::Spree::V2::Storefront::OrderSerializer

data/app/services/spree_cm_commissioner/{cart/create_guest.rb → guests/create.rb}

@@ -2,14 +2,16 @@
 # the source of truth, so quantity is raised to cover every guest (never trimmed), then
 # the cart is recalculated. The line item is locked so the insert + quantity sync are
 # atomic, mirroring Cart::AddGuest and preventing concurrent / double-triggered creates
-# from clobbering the quantity.
+# from clobbering the quantity. Quantity/hold adjustments are skipped once the order is
+# completed (e.g. a vendor adding a guest to an already-paid booking) so this stays safe
+# to call from both the storefront cart flow and tenant booking-on-behalf-of flow.
 module SpreeCmCommissioner
-  module Cart
-    class CreateGuest
+  module Guests
+    class Create
       prepend Spree::ServiceModule::Base
 
-      def call(line_item:, options: {})
-        guest = line_item.guests.new(options)
+      def call(line_item:, guest_params: {})
+        guest = line_item.guests.new(guest_params)
 
         # Release holds BEFORE mutating, using the quantities the hold was placed against
         # (Release reads live line items). Only release when this guest will actually bump
@@ -22,16 +24,15 @@ module SpreeCmCommissioner
         line_item.with_lock do
           next unless guest.save
 
-          guest.save_and_move_to_next_stage
           bump_quantity_to_cover_guests(line_item) if need_to_bump_quantity?(line_item)
         end
 
         return failure(guest) unless guest.persisted?
 
-        success(guest)
+        success(guest: guest)
       rescue StandardError => e
         CmAppLogger.error(
-          label: 'SpreeCmCommissioner::Cart::CreateGuest#call',
+          label: 'SpreeCmCommissioner::Guests::Create#call',
           data: {
             error_class: e.class.name,
             error_message: e.message
@@ -44,9 +45,10 @@ module SpreeCmCommissioner
 
       # Raise quantity one unit at a time (each unit adds variant.number_of_guests of
       # capacity) until number_of_guests covers guests.count, then recalculate. Skipped for
-      # custom guest-count metadata (accommodation/transit) and variants with no per-unit
-      # guest capacity.
+      # custom guest-count metadata (accommodation/transit), variants with no per-unit
+      # guest capacity, and completed orders (quantity is no longer adjustable post-payment).
       def need_to_bump_quantity?(line_item)
+        return false if line_item.order.completed?
         return false if line_item.custom_guest_count?
         return false if line_item.variant.number_of_guests.to_i <= 0
 

data/app/services/spree_cm_commissioner/guests/refresh_data_fill_stage.rb

@@ -0,0 +1,20 @@
+module SpreeCmCommissioner
+  module Guests
+    class RefreshDataFillStage
+      prepend ::Spree::ServiceModule::Base
+
+      def call(guest:, notify: true)
+        # incomplete? is always live, so it can't detect a before/after transition on its own —
+        # comparing it to itself would always agree. completed? reads the persisted (possibly
+        # stale) column instead, which is the actual "before" state worth comparing against.
+        was_marked_complete = guest.completed?
+
+        guest.refresh_data_fill_stage
+
+        SpreeCmCommissioner::Guests::SendDynamicFieldNotification.call(guest: guest) if notify && was_marked_complete && guest.incomplete?
+
+        success(guest: guest)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/guests/send_dynamic_field_notification.rb

@@ -0,0 +1,15 @@
+module SpreeCmCommissioner
+  module Guests
+    class SendDynamicFieldNotification
+      prepend ::Spree::ServiceModule::Base
+
+      def call(guest:)
+        notification = SpreeCmCommissioner::GuestDynamicFieldNotification.with(
+          guest: guest
+        ).deliver_later(guest.user)
+
+        success(notification: notification)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/guests/update.rb

@@ -0,0 +1,68 @@
+module SpreeCmCommissioner
+  module Guests
+    # Updates guest records with dynamic fields.
+    #
+    # Per-field replace semantics: for every dynamic_field_id mentioned in the payload, the
+    # submitted rows are the complete set of answers for that field; unmentioned fields are
+    # untouched. This still handles checkbox deselection (omit that option's row) without a
+    # submit containing only e.g. pre_registration fields wiping post_registration answers.
+    class Update
+      prepend ::Spree::ServiceModule::Base
+
+      attr_reader :guest, :guest_params
+
+      def call(guest:, guest_params:)
+        @guest = guest
+        @guest_params = guest_params
+
+        ActiveRecord::Base.transaction do
+          replace_dynamic_fields(guest_params[:guest_dynamic_fields_attributes]) if guest_params[:guest_dynamic_fields_attributes]
+          guest.update!(guest_params.except(:guest_dynamic_fields_attributes))
+        end
+
+        success(guest: guest)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(e.record, e.record.errors)
+      end
+
+      private
+
+      def replace_dynamic_fields(dynamic_fields_attributes)
+        rows = dynamic_fields_attributes.map { |raw| raw.to_h.symbolize_keys }
+
+        to_destroy, to_upsert = rows.partition { |attrs| ActiveModel::Type::Boolean.new.cast(attrs[:_destroy]) }
+        to_destroy.each { |attrs| destroy_guest_dynamic_field(attrs[:id]) }
+
+        kept = to_upsert.map { |attrs| upsert_guest_dynamic_field(attrs) }
+
+        touched_field_ids = kept.map(&:dynamic_field_id)
+        guest.guest_dynamic_fields.where(dynamic_field_id: touched_field_ids).where.not(id: kept.map(&:id)).destroy_all
+      end
+
+      # Falls back to (dynamic_field_id, dynamic_field_option_id) when no id is given (e.g. Order::Guests::Update,
+      # which never has one) so a resubmit updates the prior row instead of creating a new one and relying on the
+      # cleanup pass below to delete the old one. This also collapses duplicate option ids submitted in one
+      # request: the second lookup finds the row the first upsert just inserted, in the same transaction.
+      def upsert_guest_dynamic_field(attrs)
+        field = if attrs[:id].present?
+                  guest.guest_dynamic_fields.find_by(id: attrs[:id])
+                else
+                  guest.guest_dynamic_fields.find_by(
+                    dynamic_field_id: attrs[:dynamic_field_id],
+                    dynamic_field_option_id: attrs[:dynamic_field_option_id]
+                  )
+                end
+        field ||= guest.guest_dynamic_fields.build
+        field.assign_attributes(attrs.except(:id, :_destroy))
+        field.save!
+        field
+      end
+
+      def destroy_guest_dynamic_field(id)
+        return if id.blank?
+
+        guest.guest_dynamic_fields.find_by(id: id)&.destroy!
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/inventory_holds/validate_limits.rb

@@ -3,6 +3,7 @@ module SpreeCmCommissioner
     class ValidateLimits
       prepend ::Spree::ServiceModule::Base
       extend SpreeCmCommissioner::ServiceModuleThrowable
+      include SpreeCmCommissioner::RequestGuard
 
       ExceededActiveHoldsError = Class.new(StandardError)
       IpRateLimitError = Class.new(StandardError)
@@ -14,9 +15,13 @@ module SpreeCmCommissioner
 
       # Validates all inventory hold limits for the given order
       def call(order:)
-        validate_user_hold_limits!(order) if order.user.present?
-        validate_ip_rate_limit!(order) unless SpreeCmCommissioner::Current.load_test_bypass
-        validate_cooldown!(order)
+        # Skipped for trusted load-test requests (see RequestGuard/LoadTestBypassable).
+        # Safe: overselling is still blocked by the Redis stock check in Acquire.
+        with_request_guard do
+          validate_user_hold_limits!(order) if order.user.present?
+          validate_ip_rate_limit!(order)
+          validate_cooldown!(order)
+        end
 
         success(nil)
       rescue StandardError => e

data/app/services/spree_cm_commissioner/load_test/destroy_accounts.rb

@@ -7,10 +7,6 @@ module SpreeCmCommissioner
     class DestroyAccounts
       prepend ::Spree::ServiceModule::Base
 
-      # Scan cap for the candidate set below — bounds the query while comfortably covering realistic
-      # load-test pool sizes (mirrors the admin controller's export scan).
-      SCAN_LIMIT = 2000
-
       def call(client_id: nil, count: 20, **_ignored)
         tenant = resolve_tenant(client_id)
 
@@ -24,14 +20,15 @@ module SpreeCmCommissioner
 
       private
 
-      # `load_test_account` lives in the `private_metadata` jsonb store (double-encoded as a JSON
-      # string scalar), so it can't be filtered in SQL — load the tenant's candidates and filter
-      # with the model's own `load_test_account?` in Ruby (same approach as the admin controller).
+      # Filters the `load_test_account` flag in SQL via the model's `load_test_accounts` scope (see
+      # UserDecorator), newest first so a fresh pool is destroyed before older leftovers. No scan
+      # cap: works even on tenants with far more than 2,000 users, unlike the old
+      # `order(:id).limit(2000).select(&:...)` approach. `.first(count)` in #call adds the LIMIT, so
+      # this stays a single query.
       def load_test_accounts(tenant)
         Spree::User.where(tenant_id: tenant&.id)
-                   .order(:id)
-                   .limit(SCAN_LIMIT)
-                   .select(&:load_test_account?)
+                   .load_test_accounts
+                   .order(id: :desc)
       end
 
       def resolve_tenant(client_id)

data/app/services/spree_cm_commissioner/load_test/generate_booking_ticket_data.rb

@@ -1,22 +1,43 @@
 module SpreeCmCommissioner
   module LoadTest
-    # Generates the booking_ticket_flow load-test data for one variant so it can be used by the
-    # k6 booking flow. An admin picks a ticket variant in the dashboard; this reads its
-    # product / variant / event straight off the models and returns the payload the flow needs,
-    # plus a "can this actually be booked?" check so the tester knows it will drive the flow.
+    # Generates the cash_on_booking_ticket_flow / aba_booking_ticket_flow load-test data for one variant
+    # so it can be used by the k6 booking flow. An admin/organizer picks a ticket variant in the
+    # dashboard; this reads its product / variant / event straight off the models and returns the
+    # payload the flow needs, plus a "can this actually be booked?" check so the tester knows it
+    # will drive the flow. Mirrors GenerateVotingFixtureData's cash-on/ABA payment resolution
+    # (gems/spree_cm_commissioner/app/services/spree_cm_commissioner/load_test/
+    # generate_voting_fixture_data.rb) for the same two payment methods, applied to a variant
+    # instead of a voting session.
     #
-    # Flow: pick a ticket variant in admin -> copy this payload into
-    # load_testing/config/fixture/platform/booking_ticket_flow/<env>.json -> Env.fixture() reads
-    # that file when running k6 (load_testing/tests/platform/booking_ticket_flow).
+    # Flow: pick a ticket variant in admin/organizer -> copy this payload into
+    # load_testing/config/fixture/<platform|tenant>/<flow>/<env>.json -> Env.fixture()/
+    # Env.optionalFixture() reads that file when running k6. Note: the k6 flows themselves still
+    # read the actual payment_method_id/payway config from env vars (TENANT_PAYMENT_METHOD_ID,
+    # TENANT_PAYWAY_*), not from this JSON — payment_method_id/payway are included here purely so
+    # whoever generates the fixture can see (and copy) what's actually configured, same as
+    # GenerateVotingFixtureData's topup flows.
     #
-    # Returns success({ data: {...}, issues: [...] }). `issues` is empty when the variant
-    # is ready to load-test; otherwise it lists why the booking flow would fail. The same
-    # `issues` (plus a `ready` flag) are duplicated into `data[:metadata]` so they travel with
-    # the copied JSON — the k6 flow ignores that key, it's there for a human to read later.
+    # Returns success({ data: {...}, issues: [...] }). `issues` is empty when the variant is ready
+    # to load-test; otherwise it lists why the booking flow would fail — including "no payment
+    # method configured" for whichever flow you asked for. `issues` (plus a `ready` flag) are
+    # duplicated into `data[:metadata]` so they travel with the copied JSON — the k6 flow ignores
+    # that key, it's there for a human to read later.
     class GenerateBookingTicketData
       prepend ::Spree::ServiceModule::Base
 
-      def call(variant:)
+      FLOWS = %w[cash_on_booking_ticket_flow aba_booking_ticket_flow].freeze
+
+      # ABA's checkout endpoint is fixed regardless of tenant/environment — only `host` (sandbox
+      # vs production) differs, and that comes off the payment method. See
+      # Vpago::PaywayV2::Checkout#checkout_url in gems/spree_vpago. Mirrors
+      # GenerateVotingFixtureData::PAYWAY_CHECKOUT_PATH.
+      PAYWAY_CHECKOUT_PATH = '/api/payment-gateway/v1/payments/purchase'.freeze
+
+      # flow: which payment method to resolve — 'cash_on_booking_ticket_flow' (the default) or
+      # 'aba_booking_ticket_flow' (ABA/PayWay v2, adds a `payway` block).
+      def call(variant:, flow: 'cash_on_booking_ticket_flow')
+        raise ArgumentError, "Unknown flow: #{flow.inspect} (expected one of: #{FLOWS.join(', ')})" unless FLOWS.include?(flow)
+
         product = variant.product
         event = product.event
         issues = issues_for(variant, event)
@@ -25,15 +46,15 @@ module SpreeCmCommissioner
           event_permalink: event&.permalink,
           product_slug: product.slug,
           product_id: product.id,
-          variant_id: variant.id,
-          # Informational only — the k6 flow never reads this. Carries the readiness check into
-          # the copied JSON itself, so it's visible later without regenerating from admin.
-          metadata: {
-            ready: issues.empty?,
-            issues: issues
-          }
+          variant_id: variant.id
         }
 
+        issues.concat(payment_method_issues(variant, flow, data))
+
+        # Informational only — the k6 flow never reads this. Carries the readiness check into
+        # the copied JSON itself, so it's visible later without regenerating from admin/organizer.
+        data[:metadata] = { ready: issues.empty?, issues: issues }
+
         success(data: data, issues: issues)
       rescue StandardError => e
         failure(nil, e.message)
@@ -41,6 +62,49 @@ module SpreeCmCommissioner
 
       private
 
+      # Resolves the payment method for `flow` into `data`, and (for ABA) its payway payload.
+      # Returns the readiness issues — "no payment method configured" is blocking, same as
+      # GenerateVotingFixtureData's topup_flow_issues.
+      def payment_method_issues(variant, flow, data)
+        payment_method = resolve_payment_method(variant.vendor, flow)
+
+        return ["No #{payment_method_label(flow)} payment method configured for this tenant."] if payment_method.nil?
+
+        data[:payment_method_id] = payment_method.id
+        return [] unless flow == 'aba_booking_ticket_flow'
+
+        data[:payway] = payway_payload(payment_method)
+        return [] if payment_method.preferred_host.to_s.match?(/sandbox/i)
+
+        [
+          "ABA payment method's host (#{payment_method.preferred_host.inspect}) doesn't look like a sandbox URL — " \
+          'load tests should run against ABA\'s sandbox, not production.'
+        ]
+      end
+
+      def resolve_payment_method(vendor, flow)
+        type = flow == 'aba_booking_ticket_flow' ? Vpago::PaymentMethodDecorator::TYPE_PAYWAY_V2 : Vpago::PaymentMethodDecorator::TYPE_CASH_ON
+
+        Spree::PaymentMethod.active.where(vendor_id: vendor&.id, type: type).first
+      end
+
+      def payment_method_label(flow)
+        flow == 'aba_booking_ticket_flow' ? 'ABA' : 'cash-on'
+      end
+
+      def payway_payload(payment_method)
+        {
+          host: payment_method.preferred_host,
+          checkout_path: PAYWAY_CHECKOUT_PATH,
+          merchant_id: payment_method.preferred_merchant_id,
+          api_key: payment_method.preferred_api_key,
+          payment_option: payment_method.preferred_payment_option,
+          transaction_fee_fix: payment_method.preferred_transaction_fee_fix.to_f,
+          transaction_fee_percentage: payment_method.preferred_transaction_fee_percentage.to_f,
+          enable_pre_auth: payment_method.enable_pre_auth?
+        }
+      end
+
       # Each check returns an explanatory string when it would break the booking flow, or nil when the
       # variant is fine on that axis. Order mirrors the flow: availability first, then checkout shape.
       def issues_for(variant, event)

data/app/services/spree_cm_commissioner/order/guests/update.rb

@@ -3,7 +3,7 @@ module SpreeCmCommissioner
     module Guests
       # Whitelists submitted guest params down to whatever KYC fields and dynamic
       # fields are actually configured for the guest's line item, then delegates
-      # persistence to UpdateGuestService.
+      # persistence to SpreeCmCommissioner::Guests::Update.
       #
       # Expects params shaped as:
       #   { first_name: '...', ..., dynamic_fields: { '<dynamic_field_id>' => value_or_option_id_or_array_of_option_ids } }
@@ -11,10 +11,7 @@ module SpreeCmCommissioner
         prepend ::Spree::ServiceModule::Base
 
         def call(guest:, params:)
-          SpreeCmCommissioner::UpdateGuestService.new(guest, permitted_params(guest, params)).call
-          success(guest: guest)
-        rescue ActiveRecord::RecordInvalid => e
-          failure(guest, e.record.errors.full_messages.to_sentence)
+          SpreeCmCommissioner::Guests::Update.call(guest: guest, guest_params: permitted_params(guest, params))
         end
 
         private
@@ -28,11 +25,11 @@ module SpreeCmCommissioner
           filtered
         end
 
-        # Builds the guest_dynamic_fields_attributes array UpdateGuestService expects,
-        # restricted to dynamic fields actually enabled for this guest's product (one
+        # Builds the guest_dynamic_fields_attributes array SpreeCmCommissioner::Guests::Update
+        # expects, restricted to dynamic fields actually enabled for this guest's product (one
         # `pluck`/load, not a query per submitted field). Option-based fields (checkbox/
         # radio/selection) submit one or more selected option ids and become one
-        # GuestDynamicField row per selected option; UpdateGuestService's own auto-cleanup
+        # GuestDynamicField row per selected option; Guests::Update's own auto-cleanup
         # destroys any existing rows for options that were deselected.
         def build_dynamic_field_attributes(guest, dynamic_fields)
           return [] if dynamic_fields.blank?

data/app/services/spree_cm_commissioner/voting_contestants/advancer.rb

@@ -63,9 +63,15 @@ module SpreeCmCommissioner
       # --- Elimination ---------------------------------------------------------
 
       def sync_elimination_status
-        # No destination id — contestant was never advanced forward; nothing to mirror.
-        # e.g. vc_a { advanced_to_id: nil } → return
-        return if @voting_contestant.advanced_to_id.blank?
+        # Episode-only advancement (no session mirror was ever created) — just
+        # drop the marker when eliminated; nothing to unwind.
+        # e.g. vc_a { advanced_to_id: nil, advanced_to_episode_id: 5, eliminated: true } → clear it
+        if @voting_contestant.advanced_to_id.blank?
+          if @voting_contestant.eliminated? && @voting_contestant.advanced_to_episode_id.present?
+            @voting_contestant.update!(advanced_to_episode_id: nil)
+          end
+          return
+        end
 
         # Incomplete polymorphic ref — can't resolve a session without both parts.
         # e.g. vc_a { advanced_to_type: nil } → return
@@ -203,6 +209,7 @@ module SpreeCmCommissioner
         @voting_contestant.update!(
           advanced_to_type: nil,
           advanced_to_id: nil,
+          advanced_to_episode_id: nil,
           updated_at: Time.current
         )
       end