spree_cm_commissioner 2.5.1.pre.pre1 → 2.5.1.pre.pre2

data/app/finders/spree_cm_commissioner/routes/find.rb

@@ -0,0 +1,94 @@
+# Finder for Route records with common filtering options.
+# Usage:
+#   finder = SpreeCmCommissioner::Routes::Find.new(vendor: vendor, params: params)
+#   finder = SpreeCmCommissioner::Routes::Find.new(tenant: tenant, params: params)
+#   finder.execute
+#   returns ActiveRecord::Relation of SpreeCmCommissioner::Route
+
+module SpreeCmCommissioner
+  module Routes
+    class Find
+      def initialize(vendor: nil, tenant: nil, params: {})
+        @vendor = vendor
+        @tenant = tenant
+        @params = params || {}
+
+        @ids = Array(@params[:ids]).map(&:to_s)
+        @name = @params.dig(:filter, :name) || @params[:name]
+        @route_type = @params.dig(:filter, :route_type) || @params[:route_type]
+        @origin_place_id = @params.dig(:filter, :origin_place_id)
+        @destination_place_id = @params.dig(:filter, :destination_place_id)
+        @query = @params.dig(:filter, :query) || @params[:query]
+        @limit = (@params[:limit] || @params.dig(:page, :limit) || 50).to_i
+        @order = @params[:order] || 'created_at DESC'
+      end
+
+      def execute
+        results = base_scope
+        results = by_ids(results) if ids?
+        results = by_name(results) if name?
+        results = by_route_type(results) if route_type?
+        results = by_origin_place(results) if origin_place_id.present?
+        results = by_destination_place(results) if destination_place_id.present?
+        results = by_query(results) if query?
+
+        results.order(order_clause).limit(limit)
+      end
+
+      private
+
+      attr_reader :vendor, :tenant, :params, :ids, :name, :route_type, :origin_place_id, :destination_place_id, :query, :limit, :order
+
+      def base_scope
+        scope = SpreeCmCommissioner::Route.includes(:origin_place, :destination_place, :route_photos)
+        scope = scope.where(vendor_id: vendor.id) if vendor.present?
+        scope = scope.where(tenant_id: tenant.id) if tenant.present?
+        scope
+      end
+
+      def ids?
+        ids.present?
+      end
+
+      def name?
+        name.present?
+      end
+
+      def route_type?
+        route_type.present?
+      end
+
+      def query?
+        query.present?
+      end
+
+      def by_ids(scope)
+        scope.where(id: ids)
+      end
+
+      def by_name(scope)
+        scope.where('cm_routes.route_name ILIKE ?', "%#{name}%")
+      end
+
+      def by_route_type(scope)
+        scope.where(route_type: route_type.to_s)
+      end
+
+      def by_origin_place(scope)
+        scope.where(origin_place_id: origin_place_id)
+      end
+
+      def by_destination_place(scope)
+        scope.where(destination_place_id: destination_place_id)
+      end
+
+      def by_query(scope)
+        scope.where('cm_routes.route_name ILIKE :q OR cm_routes.short_name ILIKE :q', q: "%#{query}%")
+      end
+
+      def order_clause
+        order
+      end
+    end
+  end
+end

data/app/finders/spree_cm_commissioner/routes/find_popular.rb

@@ -1,46 +1,31 @@
-# Finds routes ordered by popularity based on order metrics.
-#
-# Routes are sorted by:
-# 1. fulfilled_order_count (completed orders) - DESC
-# 2. order_count (total orders including incomplete) - DESC
-#
-# @param route_type [Symbol, String] Optional. Filter by route type from associated trips (e.g., :ferry, :bus)
-#
-# @return [ActiveRecord::Relation<SpreeCmCommissioner::Route>] Routes with origin and destination places loaded,
-#   ordered from most to least popular
-#
-# @example Get all popular routes
-#   finder = SpreeCmCommissioner::Routes::FindPopular.new
-#   finder.execute # => Returns all routes sorted by fulfillment and order counts
-#
-# @example Get popular ferry routes
-#   finder = SpreeCmCommissioner::Routes::FindPopular.new
-#   finder.execute(route_type: :ferry) # => Returns ferry routes sorted by popularity
-#
-# @example Get popular bus routes
-#   finder = SpreeCmCommissioner::Routes::FindPopular.new
-#   finder.execute(route_type: :bus) # => Returns bus routes sorted by popularity
+# Finder to get popular route metrics scoped to a vendor or tenant.
+# Orders by fulfilled_order_count DESC, then order_count DESC.
+# Usage:
+#   finder = SpreeCmCommissioner::Routes::FindPopular.new(vendor: vendor, route_type: :bus, limit: 10)
+#   finder.execute
 
 module SpreeCmCommissioner
   module Routes
     class FindPopular
-      def execute(route_type: nil, query: nil)
-        scope(route_type: route_type, query: query)
+      def initialize(vendor: nil, tenant: nil, route_type: nil, limit: 20)
+        @vendor = vendor
+        @tenant = tenant
+        @route_type = route_type
+        @limit = limit.to_i
       end
 
-      private
-
-      def scope(route_type:, query:)
-        includes_associations = %i[origin_place destination_place]
-        includes_associations << :trips if route_type.present?
-        result = SpreeCmCommissioner::Route.includes(*includes_associations)
-
-        result = result.joins(:trips).where(cm_trips: { route_type: route_type.to_sym }) if route_type.present?
+      def execute
+        scope = SpreeCmCommissioner::Route.includes(:origin_place, :destination_place, :route_photos)
+        scope = scope.where(vendor_id: vendor.id) if vendor.present?
+        scope = scope.where(tenant_id: tenant.id) if tenant.present?
+        scope = scope.where(route_type: route_type.to_sym) if route_type.present?
+        scope.order(fulfilled_order_count: :desc, order_count: :desc)
+             .limit(limit)
+      end
 
-        result = result.where('cm_routes.route_name ILIKE ?', "%#{query}%") if query.present?
+      private
 
-        result.distinct.order(fulfilled_order_count: :desc, order_count: :desc)
-      end
+      attr_reader :vendor, :tenant, :route_type, :limit
     end
   end
 end

data/app/interactors/spree_cm_commissioner/event_qr_generator.rb

@@ -1,6 +1,6 @@
 module SpreeCmCommissioner
   class EventQrGenerator < BaseInteractor
-    delegate :operator, :event, :expired_in_mn, to: :context
+    delegate :operator, :event, :check_in_session, :expired_in_mn, to: :context
 
     EventQrStruct = Struct.new(
       :id,
@@ -18,6 +18,7 @@ module SpreeCmCommissioner
 
     def jwt_token
       payload = { event_id: event.id, operator_id: operator.id, exp: exp }
+      payload[:check_in_session_id] = check_in_session.id if check_in_session.present?
 
       context.jwt_token ||= JWT.encode(
         payload,

data/app/interactors/spree_cm_commissioner/stock/permanent_inventory_items_generator.rb

@@ -33,11 +33,18 @@ module SpreeCmCommissioner
         end
       end
 
+      # Returns dates for which inventory should be generated, based on calendar or default period.
       def inventory_dates_for(variant)
-        start_date = Time.zone.tomorrow
-        end_date = Time.zone.today + pre_inventory_days_for(variant)
+        calendar = variant.product&.service_calendar
 
-        (start_date..end_date)
+        if calendar.present?
+          calendar.start_date.upto(calendar.end_date).select { |date| calendar.service_available?(date) }
+        else
+          start_date = Time.zone.tomorrow
+          end_date = Time.zone.today + pre_inventory_days_for(variant)
+
+          start_date.upto(end_date).to_a
+        end
       end
 
       def inventory_exist?(variant, inventory_date)
@@ -68,7 +75,7 @@ module SpreeCmCommissioner
       def variants
         scope = Spree::Variant.active.with_permanent_stock.where(is_master: false)
         scope = scope.where(id: variant_ids) if variant_ids.present?
-        scope
+        scope.includes(product: :service_calendar)
       end
     end
   end

data/app/interactors/spree_cm_commissioner/stock/stock_movement_creator.rb

@@ -8,7 +8,8 @@ module SpreeCmCommissioner
 
         return context.fail!(message: Spree.t(:doesnt_track_inventory)) unless variant.track_inventory?
 
-        stock_location = Spree::StockLocation.find(stock_location_id)
+        stock_location = resolve_stock_location(variant, stock_location_id)
+
         stock_movement = stock_location.stock_movements.build(stock_movement_params)
         stock_movement.stock_item = stock_location.set_up_stock_item(variant)
 
@@ -22,6 +23,14 @@ module SpreeCmCommissioner
 
       private
 
+      def resolve_stock_location(variant, stock_location_id = nil)
+        if stock_location_id.present?
+          Spree::StockLocation.find(stock_location_id)
+        else
+          variant.vendor.stock_locations.first || variant.vendor.send(:create_stock_location)
+        end
+      end
+
       def adjust_inventory_items_async(variant_id, quantity)
         args = { variant_id: variant_id, quantity: quantity }
         CmAppLogger.log(label: "#{self.class.name}#adjust_inventory_items_async", data: args) do

data/app/interactors/spree_cm_commissioner/trip_clone_creator.rb

@@ -91,9 +91,10 @@ module SpreeCmCommissioner
       stop_params = params.dig(:trip_stops_attributes, index.to_s)
       return unless stop_params
 
-      cloned_stop.departure_time    = parse_time(stop_params[:departure_time])
-      cloned_stop.arrival_time      = parse_time(stop_params[:arrival_time])
-      cloned_stop.stop_type         = stop_params[:stop_type].presence
+      cloned_stop.departure_time = parse_time(stop_params[:departure_time])
+      cloned_stop.arrival_time = parse_time(stop_params[:arrival_time])
+      cloned_stop.allow_boarding = stop_params[:allow_boarding] if stop_params.key?(:allow_boarding)
+      cloned_stop.allow_drop_off = stop_params[:allow_drop_off] if stop_params.key?(:allow_drop_off)
       cloned_stop.location_place_id = stop_params[:location_place_id].presence
     end
 

data/app/interactors/spree_cm_commissioner/trip_stops_creator.rb

@@ -26,7 +26,7 @@ module SpreeCmCommissioner
         trip: trip,
         stop_place: origin_place,
         location_place: origin_place,
-        stop_type: :boarding
+        allow_boarding: true
       }
 
       attributes[:departure_time] = departure_time
@@ -42,7 +42,7 @@ module SpreeCmCommissioner
         trip: trip,
         stop_place: destination_place,
         location_place: destination_place,
-        stop_type: :drop_off
+        allow_drop_off: true
       }
 
       attributes[:arrival_time] = departure_time + duration_seconds.seconds

data/app/jobs/spree_cm_commissioner/guests/preload_check_in_session_ids_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module Guests
+    class PreloadCheckInSessionIdsJob < ApplicationUniqueJob
+      def perform(options)
+        event = Spree::Taxon.find(options[:event_id])
+        SpreeCmCommissioner::Guests::PreloadCheckInSessionIds.call(event: event)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/route_metrics/decrease_trip_count_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module RouteMetrics
+    class DecreaseTripCountJob < ApplicationUniqueJob
+      def perform(options = {})
+        trip = SpreeCmCommissioner::Trip.find(options[:trip_id])
+        SpreeCmCommissioner::RouteMetrics::DecreaseTripCount.call(trip: trip)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/route_metrics/increase_fulfilled_order_count_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module RouteMetrics
+    class IncreaseFulfilledOrderCountJob < ApplicationUniqueJob
+      def perform(options = {})
+        order = Spree::Order.find(options[:order_id])
+        SpreeCmCommissioner::RouteMetrics::IncreaseFulfilledOrderCount.call(order: order)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/route_metrics/increase_order_count_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module RouteMetrics
+    class IncreaseOrderCountJob < ApplicationUniqueJob
+      def perform(options = {})
+        order = Spree::Order.find(options[:order_id])
+        SpreeCmCommissioner::RouteMetrics::IncreaseOrderCount.call(order: order)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/route_metrics/increase_trip_count_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module RouteMetrics
+    class IncreaseTripCountJob < ApplicationUniqueJob
+      def perform(options = {})
+        trip = SpreeCmCommissioner::Trip.find(options[:trip_id])
+        SpreeCmCommissioner::RouteMetrics::IncreaseTripCount.call(trip: trip)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/stock/permanent_inventory_items_generator_job.rb

@@ -1,8 +1,8 @@
 module SpreeCmCommissioner
   module Stock
     class PermanentInventoryItemsGeneratorJob < ApplicationUniqueJob
-      def perform
-        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call
+      def perform(options = {})
+        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call(options)
       end
     end
   end

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

@@ -7,13 +7,13 @@ module SpreeCmCommissioner
     def increment_route_fulfilled_order_count
       return unless has_trip_ids?
 
-      SpreeCmCommissioner::Transit::RouteFulfilledOrderCountIncrementerJob.perform_later(order_id: id)
+      SpreeCmCommissioner::RouteMetrics::IncreaseFulfilledOrderCountJob.perform_later(order_id: id)
     end
 
     def increment_route_order_count
       return unless has_trip_ids?
 
-      SpreeCmCommissioner::Transit::RouteOrderCountIncrementerJob.perform_later(order_id: id)
+      SpreeCmCommissioner::RouteMetrics::IncreaseOrderCountJob.perform_later(order_id: id)
     end
   end
 end

data/app/models/spree_cm_commissioner/check_in.rb

@@ -7,13 +7,15 @@ module SpreeCmCommissioner
     enum entry_type: { normal: 0, VIP: 1 }
     enum check_in_method: { manual: 0, scan: 1, sensor: 2, nfc: 3 }
 
-    belongs_to :guest, class_name: 'SpreeCmCommissioner::Guest'
-    belongs_to :check_in_by, class_name: 'Spree::User'
+    belongs_to :guest, class_name: 'SpreeCmCommissioner::Guest', optional: false
+    belongs_to :check_in_by, class_name: 'Spree::User', optional: true
+
     has_one :line_item, class_name: 'Spree::LineItem', through: :guest
 
     belongs_to :checkinable, polymorphic: true
     belongs_to :check_in_session, class_name: 'SpreeCmCommissioner::CheckInSession', optional: true
-    before_validation :set_entry_type, on: :create
+
+    before_validation :set_entry_type, on: :create, if: -> { guest.present? }
 
     accepts_nested_attributes_for :guest, allow_destroy: true
 
@@ -21,11 +23,36 @@ module SpreeCmCommissioner
       self.entry_type = guest.entry_type
     end
 
+    # Ensure check_in_session is present when required and is eligible for the guest/ticket
+    validate :validate_check_in_session, if: -> { guest.present? }
+
     validates :guest_id,
-              uniqueness: {
-                scope: :check_in_session_id,
-                message: I18n.t('spree.check_in.already_checked_in')
-              },
+              uniqueness: { scope: :check_in_session_id, message: I18n.t('spree.check_in.already_checked_in') },
               if: -> { check_in_session_id.present? }
+
+    validates :guest_id,
+              uniqueness: { message: I18n.t('spree.check_in.already_checked_in') },
+              if: -> { check_in_session_id.blank? }
+
+    private
+
+    def validate_check_in_session
+      # Case 1: Most common scenario for events without sessions We allow this case to check-in by default.
+      # - No check-in session provided from operator app (`check_in_session_id.blank?`)
+      # - Guest has no eligible sessions, most likely because the event has no sessions
+      return true if check_in_session_id.blank? && guest.eligible_check_in_session_ids.empty?
+
+      # Case 2: Events with sessions, but operator did not provide session id
+      if check_in_session_id.blank? && guest.eligible_check_in_session_ids.any?
+        return errors.add(:check_in_session_id, I18n.t('spree.check_in.check_in_session_required'))
+      end
+
+      # Case 3: Provided session is not eligible for the guest (eg. special session for VIP tickets/guest only)
+      if check_in_session_id.present? && guest.eligible_check_in_session_ids.exclude?(check_in_session_id)
+        return errors.add(:check_in_session_id, I18n.t('spree.check_in.check_in_session_is_not_allowed_or_invalid'))
+      end
+
+      true
+    end
   end
 end

data/app/models/spree_cm_commissioner/check_in_session.rb

@@ -1,16 +1,21 @@
 module SpreeCmCommissioner
   class CheckInSession < SpreeCmCommissioner::Base
+    acts_as_list scope: :event_id
+
     belongs_to :event, class_name: 'Spree::Taxon', optional: false
+
     has_many :check_in_rules, class_name: 'SpreeCmCommissioner::CheckInRule', dependent: :destroy
 
+    scope :active, -> { where(is_archived: false) }
+
     accepts_nested_attributes_for :check_in_rules, allow_destroy: true
 
-    before_create :set_position
+    after_commit :preload_check_in_session_ids_to_event_guests
 
     private
 
-    def set_position
-      self.position ||= event.check_in_sessions.count + 1
+    def preload_check_in_session_ids_to_event_guests
+      SpreeCmCommissioner::Guests::PreloadCheckInSessionIdsJob.perform_later(event_id: event.id)
     end
   end
 end

data/app/models/spree_cm_commissioner/guest.rb

@@ -3,13 +3,15 @@ module SpreeCmCommissioner
   class Guest < SpreeCmCommissioner::Base # rubocop:disable Metrics/ClassLength
     include SpreeCmCommissioner::KycBitwise
     include SpreeCmCommissioner::PhoneNumberSanitizer
-    include SpreeCmCommissioner::StoreMetadata
     include SpreeCmCommissioner::Integrations::IntegrationMappable
 
     delegate :kyc, to: :line_item, allow_nil: true
     delegate :allowed_upload_later?, to: :line_item, allow_nil: true
 
+    enum entry_type: { normal: 0, VIP: 1 }
     enum gender: { :other => 0, :male => 1, :female => 2 }
+    enum age_group: { :adult => 0, :child => 1 }
+    enum nationality_group: { :local => 0, :foreigner => 1 }
     enum social_contact_platform: {
       :other => 0,
       :telegram => 1,
@@ -36,12 +38,15 @@ module SpreeCmCommissioner
     belongs_to :saved_guest, class_name: 'SpreeCmCommissioner::SavedGuest', optional: true
 
     has_one :reserved_block, class_name: 'SpreeCmCommissioner::ReservedBlock', dependent: :nullify
+    has_one :earliest_check_in, -> { order(:confirmed_at) }, class_name: 'SpreeCmCommissioner::CheckIn'
 
-    scope :checked_ins, -> { joins(:check_in) }
-    scope :no_show, -> { left_outer_joins(:check_in).where(cm_check_ins: { id: nil }) }
+    scope :checked_ins, -> { joins(:earliest_check_in) }
+    scope :no_show, -> { left_outer_joins(:earliest_check_in).where(cm_check_ins: { id: nil }) }
 
     has_many :state_changes, as: :stateful, class_name: 'Spree::StateChange'
     has_many :guest_dynamic_fields, dependent: :destroy, class_name: 'SpreeCmCommissioner::GuestDynamicField'
+    has_many :check_ins, class_name: 'SpreeCmCommissioner::CheckIn'
+
     accepts_nested_attributes_for :guest_dynamic_fields, allow_destroy: true, reject_if: :reject_guest_dynamic_field?
 
     belongs_to :event, class_name: 'Spree::Taxon'
@@ -56,6 +61,7 @@ module SpreeCmCommissioner
     before_validation :assign_seat_number_with_bib, if: -> { bib_number.present? }
     before_validation :assign_seat_number_with_block, if: -> { will_save_change_to_block_id? }
 
+    before_save :preload_eligible_check_in_session_ids, if: -> { new_record? }
     before_create :generate_bib, if: -> { line_item.reload && variant.bib_pre_generation_on_create? }
     after_create :preload_order_block_ids, if: -> { block_id.present? }
     after_update :preload_order_block_ids, if: :saved_change_to_block_id?
@@ -300,6 +306,57 @@ module SpreeCmCommissioner
       line_item.order.update(preload_block_ids: block_ids)
     end
 
+    def eligible_check_in_session_ids
+      # Ensure public_metadata is a hash
+      self.public_metadata = JSON.parse(public_metadata) if public_metadata.is_a?(String)
+
+      # Return as array, even if key missing
+      Array(public_metadata['eligible_check_in_session_ids'])
+    end
+
+    def eligible_check_in_session_ids=(ids)
+      # Ensure public_metadata is a hash
+      self.public_metadata = {} if public_metadata.nil?
+      self.public_metadata = JSON.parse(public_metadata) if public_metadata.is_a?(String)
+
+      public_metadata['eligible_check_in_session_ids'] = ids
+    end
+
+    def preload_eligible_check_in_session_ids
+      event = self.event || line_item&.event
+      return if event.blank?
+
+      # only preload eligible and active check-in sessions, otherwise should not checkinable.
+      self.eligible_check_in_session_ids = event.active_check_in_sessions
+                                                .select { |session| eligible_for_session?(session) }
+                                                .map(&:id)
+                                                .uniq
+    end
+
+    def eligible_for_session?(check_in_session)
+      rules = check_in_session.check_in_rules
+      return true if rules.empty?
+
+      rules.any? do |rule|
+        case rule.ruleable_type
+        when 'Spree::Product'
+          line_item.product_id == rule.ruleable_id
+        when 'Spree::Variant'
+          line_item.variant_id == rule.ruleable_id
+        when 'Spree::OptionValue'
+          line_item.variant.option_value_ids.include?(rule.ruleable_id)
+        else
+          false
+        end
+      end
+    end
+
+    def eligible_check_in_sessions
+      return SpreeCmCommissioner::CheckInSession.none if eligible_check_in_session_ids.blank?
+
+      SpreeCmCommissioner::CheckInSession.where(id: eligible_check_in_session_ids)
+    end
+
     def cancel_reserved_block!
       reserved_block.update!(
         status: :canceled,
@@ -400,31 +457,6 @@ module SpreeCmCommissioner
       line_item&.product&.dynamic_fields&.during_check_in&.any?
     end
 
-    def cm_check_in_rules
-      SpreeCmCommissioner::CheckInRule.where(ruleable_id: line_item.product_id)
-    end
-
-    def eligible_check_in_sessions
-      check_in_session_ids = []
-
-      cm_check_in_rules.includes(:check_in_session).find_each do |rule|
-        case rule.ruleable_type
-        when 'Spree::Product'
-          check_in_session_ids << rule.check_in_session_id if line_item.product_id == rule.ruleable_id
-        when 'Spree::Variant'
-          check_in_session_ids << rule.check_in_session_id if line_item.variant_id == rule.ruleable_id
-        when 'Spree::OptionValue'
-          check_in_session_ids << rule.check_in_session_id if line_item.variant.option_value_ids.include?(rule.ruleable_id)
-        end
-      end
-
-      SpreeCmCommissioner::CheckInSession.where(id: check_in_session_ids.uniq)
-    end
-
-    def can_check_in?(session)
-      eligible_check_in_sessions.include?(session)
-    end
-
     def product_dynamic_fields
       @product_dynamic_fields ||= line_item.product.dynamic_fields
     end

data/app/models/spree_cm_commissioner/guest_dynamic_field.rb

@@ -74,9 +74,9 @@ module SpreeCmCommissioner
 
       case dynamic_field.data_fill_stage.to_sym
       when :pre_registration, :post_registration
-        guest.line_item.order.completed? && guest.check_in.blank?
+        guest.line_item.order.completed? && guest.check_ins.empty?
       when :during_check_in
-        guest.check_in.present?
+        guest.check_ins.exists?
       else
         false
       end

data/app/models/spree_cm_commissioner/place.rb

@@ -21,15 +21,12 @@ module SpreeCmCommissioner
     has_many :taxon_places, class_name: 'SpreeCmCommissioner::TaxonPlace', dependent: :destroy
     has_many :taxons, through: :taxon_places
 
-    has_many :routes_as_origin, class_name: 'SpreeCmCommissioner::Route', foreign_key: :origin_place_id
-    has_many :routes_as_destination, class_name: 'SpreeCmCommissioner::Route', foreign_key: :destination_place_id
+    has_many :route_metrics_as_origin, class_name: 'SpreeCmCommissioner::RouteMetric', foreign_key: :origin_place_id
+    has_many :route_metrics_as_destination, class_name: 'SpreeCmCommissioner::RouteMetric', foreign_key: :destination_place_id
 
-    has_many :trips_as_origin, through: :routes_as_origin, source: :trips
-    has_many :trips_as_destination, through: :routes_as_destination, source: :trips
-
-    # Scopes for route-based filtering
-    scope :with_routes_as_origin, -> { joins(:routes_as_origin).distinct }
-    scope :with_routes_as_destination, -> { joins(:routes_as_destination).distinct }
+    # Scopes for route metric filtering
+    scope :with_route_metrics_as_origin, -> { joins(:route_metrics_as_origin).distinct }
+    scope :with_route_metrics_as_destination, -> { joins(:route_metrics_as_destination).distinct }
 
     def self.ransackable_attributes(auth_object = nil)
       super & %w[name code]

data/app/models/spree_cm_commissioner/pricing_actions/create_guest_adjustments.rb

@@ -0,0 +1,52 @@
+module SpreeCmCommissioner
+  module PricingActions
+    class CreateGuestAdjustments < SpreeCmCommissioner::PricingAction
+      def perform(line_item)
+        return if pricing_rule_group.pricing_rules.blank?
+        return if line_item.guests.blank?
+
+        eligible_guests = find_eligible_guests(line_item)
+        return if eligible_guests.empty?
+
+        total_amount = eligible_guests.sum do |guest|
+          compute_guest_amount(line_item, guest)
+        end
+
+        return if total_amount.zero?
+
+        create_adjustment(line_item, total_amount)
+      end
+
+      private
+
+      def find_eligible_guests(line_item)
+        line_item.guests.select do |guest|
+          guest_eligible_for_all_rules?(guest)
+        end
+      end
+
+      def guest_eligible_for_all_rules?(guest)
+        pricing_rule_group.pricing_rules.all? do |rule|
+          rule.respond_to?(:guest_eligible?) && rule.guest_eligible?(guest)
+        end
+      end
+
+      def compute_guest_amount(line_item, _guest)
+        per_guest_item = Struct.new(:amount, :currency, :quantity)
+                               .new(line_item.amount_per_guest, line_item.currency, 1)
+        calculator&.compute(per_guest_item) || 0
+      end
+
+      def create_adjustment(line_item, amount)
+        line_item.adjustments.create!(
+          amount: amount,
+          source: self,
+          adjustable: line_item,
+          order: line_item.order,
+          label: pricing_rule_group.pricing_model.name,
+          mandatory: true
+        )
+      end
+    end
+  end
+end