spree_cm_commissioner 2.7.1.pre.pre4 → 2.7.1.pre.pre6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 944d89b890c859cb1cee685f691f32bfb1f10afe8d5626b1fbf826209a9c3a9a
-  data.tar.gz: 1fa1276dcdbb1a9a5d0d3fcb1e54e6f6188c517e19a684a3245e95ac500b3695
+  metadata.gz: f88085ac9f274a24587f64dca172c3219d84b76e02385419388bc84196bdbc2e
+  data.tar.gz: 3865b929388b20b69d3a641bbdf2695ae79055e5636c5fed7033bc297b511ff5
 SHA512:
-  metadata.gz: 3263d20a3572a6b195466b3970cf853837c0ba4413d67f967400a4207e8ec68cfdd2268245a0d901f9cdccbae5948623887f47a1deb5093f51cee469b0cbffa0
-  data.tar.gz: fa7d5472e9205a55ea3fd9e4f9057f508e4fdc7b6c5db1db8d4d1127f73c72b91979591230c31ea79947f0fe9f6db46b03b6edd5645778fae96926f520945a86
+  metadata.gz: ec9862ee95fb74dc2031f22534084dbbfe01c7fd5351a248014f5a8011a97fd990d0145b1536d697877face277480bdc837fa126e64b73a41039a55268072182
+  data.tar.gz: 4b84c53d6a14a05702b5eaa78a76b1eb6f80471f15b4cc95bee9fef3772f00abe49f40c9c9d0cd78ec7761d5aa012c1d4546931a121e7e8ae2e264e7788e5bb2

data/.gitignore

@@ -34,7 +34,3 @@ vendor/bundle/
 # Cursor
 .cursor
 dump.rdb
-# Added by code-review-graph
-.code-review-graph/
-.cursorrules
-.claude

data/Gemfile.lock

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

data/app/controllers/spree/api/v2/storefront/pricing_previews_controller.rb

@@ -0,0 +1,39 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class PricingPreviewsController < ::Spree::Api::V2::BaseController
+          # GET /api/v2/tenant/pricing_previews
+          def index
+            permitted_preview_params = params.permit(SpreeCmCommissioner::PricingModels::OrderContext::PREVIEW_PERMITTED_PARAMS)
+            order_context = SpreeCmCommissioner::PricingModels::OrderContext.load!(permitted_preview_params[:order_context])
+            pricing_models_updated_at = SpreeCmCommissioner::PricingModel.joins(:vendor)
+                                                                         .where(spree_vendors: { tenant_id: nil })
+                                                                         .maximum(:updated_at)
+            cache_key = 'pricing:preview:v2:' \
+                        "#{Digest::SHA256.hexdigest(permitted_preview_params.to_json)}:" \
+                        "#{pricing_models_updated_at.to_i}"
+
+            result = Rails.cache.fetch(cache_key, expires_in: 60.seconds) do
+              SpreeCmCommissioner::PricingModels::Preview.call(order_context: order_context)
+            end
+
+            if result.success?
+              render_serialized_payload { serialize_resource(result.value[:pricing_preview]) }
+            else
+              render_error_payload(result.error, 422)
+            end
+          rescue ArgumentError => e
+            render_error_payload(e.message, 422)
+          end
+
+          private
+
+          def resource_serializer
+            SpreeCmCommissioner::V2::Storefront::PricingPreviewSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/tenant/base_controller.rb

@@ -16,10 +16,6 @@ module Spree
             set_current_tenant(@tenant)
           end
 
-          def current_vendor
-            @current_vendor ||= @tenant.active_vendor
-          end
-
           def render_serialized_payload(status = 200)
             render json: yield, status: status, content_type: content_type
           end

data/app/controllers/spree/api/v2/tenant/pricing_previews_controller.rb

@@ -0,0 +1,39 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class PricingPreviewsController < BaseController
+          # GET /api/v2/tenant/pricing_previews
+          def index
+            permitted_preview_params = params.permit(SpreeCmCommissioner::PricingModels::OrderContext::PREVIEW_PERMITTED_PARAMS)
+            order_context = SpreeCmCommissioner::PricingModels::OrderContext.load!(permitted_preview_params[:order_context])
+            pricing_models_updated_at = SpreeCmCommissioner::PricingModel.joins(:vendor)
+                                                                         .where(spree_vendors: { tenant_id: current_tenant.id })
+                                                                         .maximum(:updated_at)
+            cache_key = 'pricing:preview:v2:' \
+                        "#{Digest::SHA256.hexdigest(permitted_preview_params.to_json)}:" \
+                        "#{pricing_models_updated_at.to_i}"
+
+            result = Rails.cache.fetch(cache_key, expires_in: 60.seconds) do
+              SpreeCmCommissioner::PricingModels::Preview.call(order_context: order_context)
+            end
+
+            if result.success?
+              render_serialized_payload { serialize_resource(result.value[:pricing_preview]) }
+            else
+              render_error_payload(result.error, 422)
+            end
+          rescue ArgumentError => e
+            render_error_payload(e.message, 422)
+          end
+
+          private
+
+          def resource_serializer
+            Spree::V2::Tenant::PricingPreviewSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/factory/spree_cm_commissioner/order_telegram_message_factory.rb

@@ -48,6 +48,8 @@ module SpreeCmCommissioner
     end
 
     def line_item_content(line_item)
+      return intercity_taxi_line_item_content(line_item) if intercity_taxi?(line_item)
+
       text = []
 
       text << bold(line_item.product.name.to_s)
@@ -82,6 +84,8 @@ module SpreeCmCommissioner
       text << "Email: #{inline_code(order.email)}" if order.email.present?
       text << "Delivery Address: #{formatted_shipping_address.presence || 'N/A'}" if order.delivery_required?
 
+      append_intercity_taxi_footer(text) if intercity_taxi_order?
+
       if show_details_link && order.guests.any?
         text << ''
         text << 'View Tickets:'
@@ -125,5 +129,89 @@ module SpreeCmCommissioner
 
       formatted_rows
     end
+
+    private
+
+    def intercity_taxi?(line_item)
+      trip_for(line_item)&.intercity_taxi?
+    end
+
+    def intercity_taxi_order?
+      selected_line_items.any? { |li| intercity_taxi?(li) }
+    end
+
+    def trip_for(line_item)
+      return nil unless line_item.respond_to?(:trip_id) && line_item.trip_id.present?
+
+      @trip_cache ||= {}
+      @trip_cache[line_item.trip_id] ||= SpreeCmCommissioner::Trip.find_by(id: line_item.trip_id)
+    end
+
+    def intercity_taxi_line_item_content(line_item)
+      text = []
+      route_text = taxi_route_text(line_item)
+      departure_text = taxi_departure_text(line_item)
+      text << bold('🚗 Trip Details')
+      text << "Route: #{route_text}" if route_text.present?
+      text << "Passengers: #{line_item.passenger_count || line_item.quantity}"
+      text << "Departure: #{departure_text}" if departure_text.present?
+
+      text.compact.join("\n")
+    end
+
+    def taxi_route_text(line_item)
+      trip = trip_for(line_item)
+      return line_item.product.name if trip.blank?
+
+      origin = trip.origin_place&.name
+      destination = trip.destination_place&.name
+      vehicle = trip.vehicle_type&.name
+
+      parts = [origin, destination].compact_blank.join(' → ')
+      vehicle.present? ? "#{parts} (#{vehicle})" : parts
+    end
+
+    def taxi_departure_text(line_item)
+      return nil unless line_item.date_present?
+
+      line_item.from_date.strftime('%b %d, %Y · %H:%M')
+    end
+
+    def nationality_text
+      values = order.saved_guests.map { |sg| sg.nationality&.name.presence || sg.nationality_group&.humanize }.compact.uniq
+      return nil if values.empty?
+
+      values.join(', ')
+    end
+
+    def append_intercity_taxi_footer(text)
+      text << "Nationality: #{nationality_text}" if nationality_text.present?
+
+      pickup = selected_line_items.filter_map(&:pickup_map_place).first
+      dropoff = selected_line_items.filter_map(&:dropoff_map_place).first
+
+      append_map_place(text, '📍 Pick-up Location', pickup) if pickup
+      append_map_place(text, '📍 Drop-off Location', dropoff) if dropoff
+
+      remark = selected_line_items.filter_map { |li| li.remark.presence }.first
+      return if remark.blank?
+
+      text << ''
+      text << bold('🗒️ Notes to Driver')
+      text << ERB::Util.html_escape(remark)
+    end
+
+    def append_map_place(text, title, map_place)
+      text << ''
+      text << bold(title)
+      text << "Address: #{ERB::Util.html_escape(map_place.place_name)}" if map_place.place_name.present?
+      text << "Google Maps: #{ERB::Util.html_escape(google_maps_link(map_place))}" if google_maps_link(map_place).present?
+    end
+
+    def google_maps_link(map_place)
+      return nil if map_place.lat.blank? || map_place.lng.blank?
+
+      "https://www.google.com/maps/search/?api=1&query=#{map_place.lat},#{map_place.lng}"
+    end
   end
 end

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

@@ -13,11 +13,11 @@ module SpreeCmCommissioner
       def execute
         scope
           .where(default_state_id: state_id)
-          .where(inventory_items: { inventory_date: stay_dates })
-          .where('CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-adults\' AS INTEGER) +
-                  CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-kids\' AS INTEGER) >= ?', number_of_guests
+          .where('spree_variants.track_inventory = FALSE OR cm_inventory_items.inventory_date BETWEEN ? AND ?', from_date, to_date)
+          .where('spree_variants.track_inventory = FALSE OR cm_inventory_items.quantity_available > 0')
+          .where('COALESCE(CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-adults\' AS INTEGER), 0) +
+                  COALESCE(CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-kids\' AS INTEGER), 0) >= ?', number_of_guests
           )
-          .where('inventory_items.quantity_available > 0')
           .distinct
       end
 
@@ -25,7 +25,8 @@ module SpreeCmCommissioner
 
       def scope
         Spree::Vendor
-          .joins(variants: :inventory_items)
+          .joins(products: :variants)
+          .joins('LEFT OUTER JOIN cm_inventory_items ON cm_inventory_items.variant_id = spree_variants.id')
           .where(primary_product_type: :accommodation, state: :active)
       end
 

data/app/helpers/spree_cm_commissioner/admin/homepage_segment_helper.rb

@@ -15,8 +15,6 @@ module SpreeCmCommissioner
           'badge badge-success text-uppercase'
         when :football
           'badge badge-dark text-uppercase'
-        when :show
-          'badge badge-danger text-uppercase'
         else
           'badge'
         end

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

@@ -8,8 +8,7 @@ module SpreeCmCommissioner
       tour: 0b00100,
       accommodation: 0b01000,
       things_to_do: 0b10000,
-      football: 0b100000,
-      show: 0b1000000
+      football: 0b100000
     }.freeze
 
     BIT_SEGMENT.each do |segment, bit_value|

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

@@ -45,8 +45,7 @@ module SpreeCmCommissioner
       'color' => 'color',
       'ticket-type' => 'string',
       'seat-type' => 'string',
-      'intercity-taxi' => 'string',
-      'vote-package' => 'integer'
+      'intercity-taxi' => 'string'
     }.freeze
 
     included do

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

@@ -26,10 +26,8 @@ module SpreeCmCommissioner
 
       state_machine.after_transition to: :canceled, do: :precalculate_conversion
       state_machine.after_transition to: :canceled, do: :restock_inventory!
-      state_machine.after_transition to: :canceled, do: :de_allocate_resources
 
       state_machine.after_transition to: :complete, do: :increment_route_fulfilled_order_count
-      state_machine.after_transition to: :complete, do: :allocate_resources
 
       scope :accepted, -> { where(request_state: 'accepted') }
 
@@ -330,13 +328,5 @@ module SpreeCmCommissioner
       factory = OrderTelegramMessageFactory.new(title: title, order: self)
       TelegramNotificationSenderJob.perform_later(chat_id: chat_id, message: factory.message, parse_mode: factory.parse_mode)
     end
-
-    def allocate_resources
-      SpreeCmCommissioner::VotingCreditAllocationJob.perform_later(order_id: id)
-    end
-
-    def de_allocate_resources
-      SpreeCmCommissioner::VotingCreditDeAllocationJob.perform_later(order_id: id)
-    end
   end
 end

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

@@ -5,7 +5,7 @@ module SpreeCmCommissioner
   module ProductType
     extend ActiveSupport::Concern
 
-    PRODUCT_TYPES = %i[accommodation service ecommerce transit show_episode vote_package].freeze
+    PRODUCT_TYPES = %i[accommodation service ecommerce transit].freeze
     PERMANENT_STOCK_PRODUCT_TYPES = %w[accommodation service transit].freeze
     PRE_INVENTORY_DAYS = { 'transit' => 90, 'accommodation' => 365, 'service' => 30 }.freeze
 

data/app/models/spree_cm_commissioner/pricing_action.rb

@@ -9,8 +9,8 @@ module SpreeCmCommissioner
 
     delegate :pricing_rules, to: :pricing_rule_group
 
-    def perform(_options = {})
-      raise NotImplementedError, "#{self.class}#perform must be implemented"
+    def preview(_options = {})
+      raise NotImplementedError, "#{self.class}#preview must be implemented"
     end
 
     def compute_amount(adjustable)

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

@@ -1,68 +1,60 @@
 module SpreeCmCommissioner
   module PricingActions
     class CreateGuestAdjustments < SpreeCmCommissioner::PricingAction
-      def perform(options = {})
-        line_items = extract_line_items(options)
+      def preview(options = {})
+        line_item_contexts = Array(options[:line_item_contexts])
 
-        return if pricing_rule_group.pricing_rules.blank?
-        return if line_items.blank?
+        return [] if pricing_rule_group.pricing_rules.blank?
+        return [] if line_item_contexts.blank?
 
-        line_items.each do |line_item|
-          perform_for_line_item(line_item)
+        line_item_contexts.filter_map do |line_item_context|
+          preview_for_line_item_context(line_item_context)
         end
       end
 
       private
 
-      def extract_line_items(options)
-        return [options] if options.respond_to?(:guests)
+      def preview_for_line_item_context(line_item_context)
+        return nil if line_item_context.guest_contexts.blank?
 
-        Array(options[:line_items])
+        eligible_guest_contexts = find_eligible_guest_contexts(line_item_context)
+        return nil if eligible_guest_contexts.empty?
+
+        total = eligible_guest_contexts.sum do |guest_context|
+          compute_guest_amount(line_item_context, guest_context)
+        end
+
+        return nil if total.zero?
+
+        PricingModels::PreviewAdjustment.new(
+          label: label,
+          amount: total,
+          action_type: 'create_guest_adjustments',
+          pricing_action: self,
+          adjustable_type: 'Spree::LineItem',
+          adjustable_id: line_item_context.id,
+          line_item_id: line_item_context.id,
+          guest_ids: eligible_guest_contexts.map(&:id).compact
+        )
       end
 
-      def find_eligible_guests(line_item)
-        line_item.guests.select do |guest|
-          guest_eligible_for_all_rules?(guest)
+      def find_eligible_guest_contexts(line_item_context)
+        line_item_context.guest_contexts.select do |guest_context|
+          guest_context_eligible_for_all_rules?(guest_context, line_item_context)
         end
       end
 
-      def guest_eligible_for_all_rules?(guest)
+      def guest_context_eligible_for_all_rules?(guest_context, line_item_context)
         pricing_rule_group.pricing_rules.all? do |rule|
-          rule.respond_to?(:guest_eligible?) && rule.guest_eligible?(guest)
+          rule.respond_to?(:guest_eligible?) && rule.guest_eligible?(guest_context, line_item_context)
         end
       end
 
-      def compute_guest_amount(line_item, _guest)
+      def compute_guest_amount(line_item_context, _guest_context)
         per_guest_item = Struct.new(:amount, :currency, :quantity)
-                               .new(line_item.amount_per_guest, line_item.currency, 1)
+                               .new(line_item_context.price, line_item_context.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
-
-      def perform_for_line_item(line_item)
-        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
     end
   end
 end

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

@@ -1,19 +1,26 @@
 module SpreeCmCommissioner
   module PricingActions
     class CreateLineItemAdjustments < SpreeCmCommissioner::PricingAction
-      def perform(options = {})
-        order = options[:order]
-        line_items = options[:line_items] || []
+      def preview(options = {})
+        line_item_contexts = Array(options[:line_item_contexts])
 
-        return if line_items.blank?
+        return [] if line_item_contexts.blank?
 
-        line_items.each do |line_item|
-          create_unique_adjustment(order, line_item)
-        end
-      end
+        line_item_contexts.filter_map do |line_item_context|
+          amount = compute_amount(line_item_context)
+          next nil if amount.zero?
 
-      def compute_amount(line_item)
-        compute(line_item)
+          PricingModels::PreviewAdjustment.new(
+            label: label,
+            amount: amount,
+            action_type: 'create_line_item_adjustments',
+            pricing_action: self,
+            adjustable_type: 'Spree::LineItem',
+            adjustable_id: line_item_context.id,
+            line_item_id: line_item_context.id,
+            guest_ids: []
+          )
+        end
       end
     end
   end

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

@@ -1,69 +1,68 @@
 module SpreeCmCommissioner
   module PricingActions
     class CreateRouteAdjustments < SpreeCmCommissioner::PricingAction
-      def perform(options = {})
-        order = options[:order]
-        line_items = options[:line_items] || []
+      def preview(options = {})
+        order_context = options[:order_context]
+        line_item_contexts = Array(options[:line_item_contexts])
 
-        return if pricing_rules.blank?
-        return if line_items.blank?
+        return [] if pricing_rules.blank?
+        return [] if line_item_contexts.blank?
 
-        eligible_guests = collect_unique_eligible_guests(line_items)
-        return if eligible_guests.empty?
+        eligible_guest_contexts = collect_unique_eligible_guest_contexts(line_item_contexts)
+        return [] if eligible_guest_contexts.empty?
 
-        total_amount = compute_total_amount(order, eligible_guests)
-        return if total_amount.zero?
+        total_amount = compute_total_amount(line_item_contexts, eligible_guest_contexts)
+        return [] if total_amount.zero?
 
-        create_route_adjustment(order, total_amount)
+        [
+          PricingModels::PreviewAdjustment.new(
+            label: label,
+            amount: total_amount,
+            action_type: 'create_route_adjustments',
+            pricing_action: self,
+            adjustable_type: 'Spree::Order',
+            adjustable_id: order_context.id,
+            line_item_id: nil,
+            guest_ids: eligible_guest_contexts.map(&:id).compact
+          )
+        ]
       end
 
       private
 
-      def collect_unique_eligible_guests(line_items)
+      def collect_unique_eligible_guest_contexts(line_item_contexts)
         seen = {}
 
-        line_items.each_with_object([]) do |line_item, result|
-          line_item.guests.select { |guest| guest_eligible?(guest) }.each_with_index do |guest, index|
-            key = guest.saved_guest_id.present? ? [guest.saved_guest_id, index] : guest.id
+        line_item_contexts.each_with_object([]) do |line_item_context, result|
+          line_item_context.guest_contexts.select { |gc| guest_context_eligible?(gc, line_item_context) }.each_with_index do |guest_context, index|
+            key = guest_context.saved_guest_id.present? ? [guest_context.saved_guest_id, index] : guest_context.id
             next if seen[key]
 
             seen[key] = true
-            result << guest
+            result << guest_context
           end
         end
       end
 
-      def guest_eligible?(guest)
+      def guest_context_eligible?(guest_context, line_item_context)
         pricing_rules.all? do |rule|
-          !rule.respond_to?(:guest_eligible?) || rule.guest_eligible?(guest)
+          !rule.respond_to?(:guest_eligible?) || rule.guest_eligible?(guest_context, line_item_context)
         end
       end
 
-      def compute_total_amount(order, guests)
-        guests.sum { |guest| compute_per_guest_amount(order, guest) }
-      end
-
-      def compute_per_guest_amount(order, guest)
-        item = build_per_guest_item(order, guest)
-        compute_amount(item)
+      def compute_total_amount(line_item_contexts, eligible_guest_contexts)
+        eligible_guest_contexts.sum do |guest_context|
+          line_item_context = line_item_contexts.find { |l| l.id == guest_context.line_item_id }
+          compute_per_guest_amount(line_item_context, guest_context)
+        end
       end
 
-      def build_per_guest_item(order, guest)
-        Struct.new(:amount, :currency, :quantity).new(
-          guest.line_item.amount_per_guest,
-          order_currency(order),
-          1
-        )
-      end
+      def compute_per_guest_amount(line_item_context, _guest_context)
+        return 0 if line_item_context.nil?
 
-      def create_route_adjustment(order, amount)
-        adjustments.create!(
-          adjustable: order,
-          amount: amount,
-          order: order,
-          label: label,
-          mandatory: true
-        )
+        item = Struct.new(:amount, :currency, :quantity)
+                     .new(line_item_context.price, line_item_context.currency, 1)
+        compute_amount(item)
       end
     end
   end

data/app/models/spree_cm_commissioner/pricing_model.rb

@@ -17,30 +17,28 @@ module SpreeCmCommissioner
 
     enum status: { draft: 0, active: 1, archived: 2 }
 
-    # Activates pricing model for an order (similar to Spree::Promotion#activate)
-    def activate(order:, line_items:)
-      pricing_rule_groups.select(&:active?).each do |group|
-        activate_group(group, order, line_items)
+    def preview(order_context:, line_item_contexts:)
+      eligible_groups(line_item_contexts).flat_map do |group|
+        group.pricing_action&.preview(
+          order_context: order_context,
+          line_item_contexts: line_item_contexts
+        ) || []
       end
     end
 
     private
 
-    def activate_group(group, order, line_items)
-      eligible_rules = group.pricing_rules.select { |r| any_line_item_eligible?(r, line_items) }
+    def eligible_groups(line_item_contexts)
+      pricing_rule_groups.select(&:active?).select do |group|
+        eligible_rules = group.pricing_rules.select { |r| any_line_item_context_eligible?(r, line_item_contexts) }
+        next false if eligible_rules.empty?
 
-      return if eligible_rules.empty?
-
-      if group_eligible?(group, eligible_rules)
-
-        group.pricing_action&.perform(order: order, line_items: line_items)
-      else
-        Rails.logger.info("PricingRuleGroup #{group.id} not eligible for order #{order.id}")
+        group_eligible?(group, eligible_rules)
       end
     end
 
-    def any_line_item_eligible?(rule, line_items)
-      line_items.any? { |li| rule.eligible?(li) }
+    def any_line_item_context_eligible?(rule, line_item_contexts)
+      line_item_contexts.any? { |line_item_context| rule.eligible?(line_item_context) }
     end
 
     def group_eligible?(group, eligible_rules)

data/app/models/spree_cm_commissioner/pricing_rule.rb

@@ -8,7 +8,7 @@ module SpreeCmCommissioner
       raise 'eligible? should be implemented in a sub-class of SpreeCmCommissioner::PricingRule'
     end
 
-    def guest_eligible?(_guest)
+    def guest_eligible?(_guest_context, _line_item_context)
       raise 'guest_eligible? should be implemented in a sub-class of SpreeCmCommissioner::PricingRule'
     end