spree_cm_commissioner 2.13.2 → 2.13.3.pre.pre2

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -2,10 +2,15 @@ module SpreeCmCommissioner
   class InventoryItem < Base
     include SpreeCmCommissioner::ProductType
     include SpreeCmCommissioner::StoreMetadata
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
 
     MAX_DISPLAY_STOCK = 20
     LOW_STOCK_THRESHOLD = 20
 
+    store_public_metadata :last_synced_at, :datetime
+    store_public_metadata :original_price, :integer
+    store_public_metadata :currency, :string
+
     # Association
     belongs_to :variant, class_name: 'Spree::Variant', optional: false
 
@@ -36,6 +41,11 @@ module SpreeCmCommissioner
 
     before_save -> { self.product_type = variant.product_type }, if: -> { product_type.nil? }
 
+    # A night whose inventory a partner owns (Integration#inventory_external_wins?) starts closed: its
+    # count is only our seed from the physical room count, which the partner may already have sold
+    # elsewhere. The partner's first availability push opens it.
+    before_create -> { self.closed = true }, if: -> { permanent_stock? && variant&.inventory_external_wins? }
+
     after_commit :schedule_product_cache_invalidation
     after_commit :publish_live_stock_status_to_firestore
 
@@ -109,6 +119,14 @@ module SpreeCmCommissioner
     # This method is only used when admin update stock
     def adjust_quantity!(quantity)
       with_lock do
+        # Warm the Redis cache from the current DB value BEFORE applying the delta below.
+        # adjust_quantity_in_redis treats a missing key as 0, so a negative delta against a
+        # never-cached key would compute e.g. 0 - 3 = -3, clamp to 0, and permanently cache the
+        # wrong value (the read path only self-heals from a genuinely *missing* key, not a wrong
+        # one). This is the same warm-before-delta pattern already used by
+        # InventoryItems::AdjustAvailableQuantity for the same reason.
+        SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new([self]).call
+
         # IMPORTANT: Apply quantity changes directly without defensive clamping.
         # The model validation will catch any attempts to go negative, surfacing bugs
         # in upstream logic rather than silently losing data.

data/app/models/spree_cm_commissioner/line_item_decorator.rb

@@ -3,6 +3,8 @@ module SpreeCmCommissioner
     def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       include_modules(base)
 
+      base.money_methods :service_fee_total
+
       base.belongs_to :accepter, class_name: 'Spree::User', optional: true
       base.belongs_to :rejecter, class_name: 'Spree::User', optional: true
       base.belongs_to :event, class_name: 'Spree::Taxon', optional: true, inverse_of: :line_items

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -1,6 +1,6 @@
 module SpreeCmCommissioner
   module OrderDecorator
-    def self.prepended(base) # rubocop:disable Metrics/MethodLength
+    def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       base.include SpreeCmCommissioner::OrderChannelBitwise
       base.include SpreeCmCommissioner::StoreMetadata
       base.include SpreeCmCommissioner::PhoneNumberSanitizer
@@ -11,6 +11,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::OrderScopes
       base.include SpreeCmCommissioner::TicketTransferable
       base.include SpreeCmCommissioner::OrderQrCodeable
+      base.include SpreeCmCommissioner::Integrations::IntegrationMappable
 
       base.before_create :link_by_phone_number
       base.before_create :associate_customer
@@ -21,6 +22,8 @@ module SpreeCmCommissioner
       base.store_private_metadata :preload_main_trip_ids, :array, default: []
       base.store_public_metadata :order_options, :array, default: []
 
+      base.money_methods :service_fee_total
+
       base.validates :promo_total, base::MONEY_VALIDATION
       base.validates :phone_number, presence: true, if: :require_phone_number
 
@@ -49,6 +52,7 @@ module SpreeCmCommissioner
       base.has_many :reserved_blocks, through: :guests, class_name: 'SpreeCmCommissioner::ReservedBlock'
       base.has_many :guest_card_classes, class_name: 'SpreeCmCommissioner::GuestCardClass', through: :variants
       base.has_many :product_completion_steps, class_name: 'SpreeCmCommissioner::ProductCompletionStep', through: :line_items
+      base.has_many :audit_events, class_name: 'SpreeCmCommissioner::AuditEvent', as: :auditable
 
       base.delegate :customer, to: :user, allow_nil: true
 
@@ -156,6 +160,14 @@ module SpreeCmCommissioner
       line_items.any?(&:delivery_required?)
     end
 
+    # Mirrors create_tax_charge! (core/app/models/spree/order.rb) — wired into the same
+    # checkout transitions via SpreeCmCommissioner::OrderStateMachine, plus called directly
+    # from TransitOrder::Create and DraftOrders::Create, which build orders outside the
+    # checkout state machine entirely.
+    def create_service_fee_charge!
+      SpreeCmCommissioner::ServiceFeeRule.adjust(self, line_items)
+    end
+
     # overrided
     def payment_required?
       return false if need_confirmation?

data/app/models/spree_cm_commissioner/order_updater_decorator.rb

@@ -5,6 +5,37 @@ module SpreeCmCommissioner
       order.item_total = line_items.sum(&:amount)
       update_order_total
     end
+
+    # Rolls line items' service_fee_total up into the order (display total only —
+    # the fee is already folded into order.adjustment_total/total via the
+    # non_taxable_adjustment_total bucket, see Adjustable::Adjuster::ServiceFee).
+    def update_adjustment_total
+      super
+      order.service_fee_total = line_items.sum(:service_fee_total)
+    end
+
+    # Duplicates Spree::OrderUpdater#persist_totals' update_columns call (spree_core 4.5.3)
+    # rather than calling super + a second update_columns for service_fee_total, to keep this
+    # to a single UPDATE per order -- with read replicas/connection pooling in front of this,
+    # a second round-trip per persist_totals call isn't free. Must be kept in sync if core ever
+    # changes that column list.
+    def persist_totals
+      order.update_columns( # rubocop:disable Rails/SkipsModelValidations
+        payment_state: order.payment_state,
+        shipment_state: order.shipment_state,
+        item_total: order.item_total,
+        item_count: order.item_count,
+        adjustment_total: order.adjustment_total,
+        included_tax_total: order.included_tax_total,
+        additional_tax_total: order.additional_tax_total,
+        payment_total: order.payment_total,
+        shipment_total: order.shipment_total,
+        promo_total: order.promo_total,
+        total: order.total,
+        service_fee_total: order.service_fee_total,
+        updated_at: Time.current
+      )
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/place.rb

@@ -1,5 +1,7 @@
 module SpreeCmCommissioner
   class Place < Base
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
+
     acts_as_nested_set
 
     validates :reference, presence: true, if: :validate_reference?

data/app/models/spree_cm_commissioner/redis_stock/cached_inventory_items_builder.rb

@@ -49,7 +49,8 @@ module SpreeCmCommissioner
           quantity_locked_on_hold: cache_inventory(locked_hold_keys[index], item, item.quantity_locked_on_hold, locked_hold[index]),
           max_capacity: item.max_capacity,
           inventory_item_id: item.id,
-          variant_id: item.variant_id
+          variant_id: item.variant_id,
+          closed: item.closed
         )
       end
 

data/app/models/spree_cm_commissioner/route.rb

@@ -1,6 +1,7 @@
 module SpreeCmCommissioner
   class Route < Base
     include SpreeCmCommissioner::RouteType
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
     include SpreeCmCommissioner::StoreMetadata
     include SpreeCmCommissioner::ServiceOrigin
 

data/app/models/spree_cm_commissioner/seat_layout.rb

@@ -1,5 +1,6 @@
 module SpreeCmCommissioner
   class SeatLayout < Base
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
     include StoreMetadata
 
     # Whole-screen theming for the app's seat-selection scaffold (background / app bar / status

data/app/models/spree_cm_commissioner/service_fee_rule.rb

@@ -0,0 +1,183 @@
+module SpreeCmCommissioner
+  class ServiceFeeRule < SpreeCmCommissioner::Base
+    ALLOWED_RULEABLE_TYPES = %w[Spree::Product Spree::Taxon Spree::Vendor].freeze
+
+    include Spree::AdjustmentSource
+    include Spree::CalculatedAdjustments
+
+    # Spree::AdjustmentSource's own `has_many :adjustments, as: :source` has no class_name, so
+    # Rails infers it from the association name relative to *this* class's namespace
+    # (SpreeCmCommissioner::Adjustment), which doesn't exist. Redeclaring it here overrides that
+    # default — same fix SpreeCmCommissioner::PricingAction already needed for the same reason.
+    has_many :adjustments, as: :source, class_name: 'Spree::Adjustment'
+
+    belongs_to :ruleable, polymorphic: true, optional: true
+
+    # Only meaningful on a ruleable-less row (see the tenant_id absence validation below): a
+    # tenant's own default, distinct from the true platform-wide default (tenant_id AND ruleable
+    # both nil). Not used on Product/Vendor/Event-scoped rows — their tenant is already implied by
+    # the ruleable itself (a vendor belongs to exactly one tenant), so storing it there too would
+    # just be a second copy that could drift out of sync.
+    multi_tenant :tenant, class_name: 'SpreeCmCommissioner::Tenant'
+
+    before_validation :normalize_ruleable, :normalize_currency
+
+    validates :currency, presence: true
+    validates :ruleable_type, inclusion: { in: ALLOWED_RULEABLE_TYPES }, allow_nil: true
+    validates :ruleable_id, presence: true, if: -> { ruleable_type.present? }
+    validates :tenant_id, absence: true, if: -> { ruleable_type.present? }
+
+    # Only one active rule per (ruleable, tenant, currency). The global rule is a
+    # ruleable-less row, so ruleable_type / ruleable_id are both nil for it; tenant_id nil on
+    # that same row means "true platform-wide," not "unscoped."
+    validates :currency,
+              uniqueness: {
+                scope: %i[ruleable_type ruleable_id tenant_id active],
+                conditions: -> { where(active: true) },
+                case_sensitive: false,
+                message: lambda { |object, _data|
+                  I18n.t('service_fee.rules.rule_already_exists_for_scope',
+                         scope_type: object.ruleable_type_label, currency: object.currency
+                  )
+                }
+              },
+              if: :active?
+
+    scope :active_rules, -> { where(active: true) }
+    scope :for_currency, -> (currency) { where(currency: currency.to_s.upcase) }
+
+    # Finds the active rule for the given ruleable (nil = global) and currency.
+    scope :active_for, lambda { |ruleable:, currency:|
+      active_rules
+        .for_currency(currency)
+        .where(ruleable_type: ruleable&.class&.base_class&.name, ruleable_id: ruleable&.id)
+    }
+
+    # Finds the ruleable-less rule for a specific tenant (nil tenant_id = true platform-wide).
+    scope :active_for_tenant, lambda { |tenant_id:, currency:|
+      active_rules
+        .for_currency(currency)
+        .where(ruleable_type: nil, ruleable_id: nil, tenant_id: tenant_id)
+    }
+
+    # Deletes all service-fee adjustments on these line items, then recreates them from
+    # whichever rule currently resolves for each one. Mirrors Spree::TaxRate.adjust: a plain
+    # destroy-then-create (not create_unique_adjustment, which only guards against duplicates
+    # and would leave a stale amount in place after a rule edit or a quantity change).
+    def self.adjust(order, line_items)
+      Spree::Adjustment.where(adjustable: line_items).service_fee.destroy_all
+
+      line_items.each do |line_item|
+        rule = resolve_for(line_item: line_item, currency: order.currency)
+        rule&.adjust(order, line_item)
+      end
+    end
+
+    # create_adjustment (from Spree::AdjustmentSource) is protected — callable with an explicit
+    # receiver only from inside another instance method of this class, not from the self.adjust
+    # class method above, where self is the class rather than an instance. This public wrapper is
+    # the same shape Spree::TaxRate#adjust uses for the identical reason.
+    def adjust(order, line_item)
+      create_adjustment(order, line_item)
+    end
+
+    # Walks product -> event -> vendor -> global, returning the first active rule that matches the
+    # currency. The product/event/vendor leg mirrors
+    # SpreeCmCommissioner::TicketTransfers::FeeCalculator's precedence.
+    #
+    # "Global" means two different things depending on whether the vendor belongs to a tenant:
+    # - No tenant (a base BookMe+ vendor): the true platform-wide default (tenant_id nil).
+    # - Has a tenant: ONLY that tenant's own default (tenant_id: vendor.tenant_id) — deliberately
+    #   does NOT fall back to the platform-wide default if the tenant hasn't set one. Each
+    #   white-label tenant is expected to configure their own fee (or explicitly have none); a
+    #   tenant silently inheriting BookMe+'s own fee because they forgot to configure one would be
+    #   a surprising, not a sensible, default.
+    def self.resolve_for(line_item:, currency:)
+      ruleables_for(line_item).each do |ruleable|
+        rule = active_for(ruleable: ruleable, currency: currency).first
+        return rule if rule.present?
+      end
+
+      active_for_tenant(tenant_id: vendor_for(line_item)&.tenant_id, currency: currency).first
+    end
+
+    def self.ruleables_for(line_item)
+      [line_item.product, line_item.event, vendor_for(line_item)]
+    end
+
+    def self.vendor_for(line_item)
+      product = line_item.product
+      product.respond_to?(:vendor) ? product.vendor : nil
+    end
+
+    # Spree calculators only expose a fixed, hardcoded set of calculable model types
+    # (Rails.application.config.spree.calculators is a plain Struct — tax_rates,
+    # shipping_methods, promotion_actions_*). There's no slot for a commissioner-owned
+    # model, so — same as SpreeCmCommissioner::PricingAction — we expose our own list
+    # instead of relying on the inherited `calculators` class method.
+    def self.available_calculator_types
+      [SpreeCmCommissioner::Calculators::ServiceFeePercent, SpreeCmCommissioner::Calculators::ServiceFeeFlatAmount]
+    end
+
+    def compute_amount(line_item)
+      calculator&.compute(line_item) || 0
+    end
+
+    # A short, human-readable summary for admin listings, e.g. "10%" or "$0.25" — so a rule's
+    # actual fee doesn't require opening it to see. Two calculator types (not one combined
+    # percent+flat calculator) means there's always exactly one number to show here.
+    def fee_description
+      case calculator
+      when SpreeCmCommissioner::Calculators::ServiceFeePercent
+        "#{calculator.preferred_percent.to_d.round(2).to_s('F')}%"
+      when SpreeCmCommissioner::Calculators::ServiceFeeFlatAmount
+        Spree::Money.new(calculator.preferred_flat_amount, currency: currency).to_s
+      when nil
+        Spree.t(:service_fee_rule_not_configured)
+      else
+        calculator.description
+      end
+    end
+
+    def scope_label
+      if ruleable.blank?
+        # A tenant-scoped row is that tenant's own "global" — it never falls back to the
+        # BookMe+-level one (see resolve_for), so it isn't really "global" in the broad sense;
+        # labeled as its own Tenant scope rather than reusing the word "Global" for both.
+        return Spree.t(:service_fee_rule_scope_tenant, name: tenant&.name || "##{tenant_id}") if tenant_id.present?
+
+        return Spree.t(:service_fee_rule_scope_global)
+      end
+
+      label_value = ruleable.respond_to?(:name) ? ruleable.name.to_s : "##{ruleable_id}"
+      "#{ruleable_type_label}: #{label_value}"
+    end
+
+    def ruleable_type_label
+      case ruleable_type
+      when 'Spree::Product' then Spree.t(:service_fee_rule_scope_product)
+      when 'Spree::Taxon' then Spree.t(:service_fee_rule_scope_event)
+      when 'Spree::Vendor' then Spree.t(:service_fee_rule_scope_vendor)
+      else ruleable_type&.demodulize || Spree.t(:service_fee_rule_scope_global)
+      end
+    end
+
+    protected
+
+    def label
+      'Service Fee'
+    end
+
+    private
+
+    # "Global" dropdown sends "" not nil. Convert to nil so validations and uniqueness checks work.
+    def normalize_ruleable
+      self.ruleable_type = nil if ruleable_type.blank?
+      self.ruleable_id   = nil if ruleable_type.nil?
+    end
+
+    def normalize_currency
+      self.currency = currency.to_s.upcase.presence
+    end
+  end
+end

data/app/models/spree_cm_commissioner/stock/availability_checker.rb

@@ -23,7 +23,7 @@ module SpreeCmCommissioner
         return true if variant.need_confirmation?
         return false if cached_inventory_items.empty?
 
-        cached_inventory_items.all? { |item| item.active? && quantity_in_pool(item, include_locked: include_locked) >= quantity }
+        cached_inventory_items.all? { |item| item.sellable? && quantity_in_pool(item, include_locked: include_locked) >= quantity }
       end
 
       # The cache row carries both pools, so choosing between them is a read, not another Redis trip.

data/app/models/spree_cm_commissioner/stock/order_availability_checker.rb

@@ -45,7 +45,7 @@ module SpreeCmCommissioner
         # stock, i.e. read sold out exactly when its allotment was still sellable.
         cached_inventory_items.all? do |item|
           quantity = line_item.locked_stock? ? item.quantity_locked : item.quantity_available
-          item.active? && quantity >= line_item.quantity
+          item.sellable? && quantity >= line_item.quantity
         end
       end
     end

data/app/models/spree_cm_commissioner/stock_item_decorator.rb

@@ -15,6 +15,10 @@ module SpreeCmCommissioner
     private
 
     def create_inventory_items
+      # Skip automatic inventory generation when variant has manual_generate_inventory_items set to true
+      # Use case: For variants where inventory items need to be manually created/managed (e.g., external integrations)
+      return if variant.manual_generate_inventory_items?
+
       SpreeCmCommissioner::InventoryItems::GenerateInventoryItemsJob.perform_later(variant_id: variant.id)
     end
 

data/app/models/spree_cm_commissioner/trip.rb

@@ -2,6 +2,7 @@ module SpreeCmCommissioner
   class Trip < Base
     include SpreeCmCommissioner::StoreMetadata
     include SpreeCmCommissioner::RouteType
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
     include SpreeCmCommissioner::ServiceOrigin
 
     attr_accessor :hours, :minutes, :seconds
@@ -38,7 +39,7 @@ module SpreeCmCommissioner
     after_commit :update_route_price_range, on: %i[create update]
 
     belongs_to :vendor, class_name: 'Spree::Vendor', inverse_of: :trips, optional: false
-    belongs_to :product, class_name: 'Spree::Product', inverse_of: :trip, optional: false
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :trip, optional: true
 
     belongs_to :service_origin, class_name: 'Spree::Taxon', optional: true
 

data/app/models/spree_cm_commissioner/trip_stop.rb

@@ -1,5 +1,7 @@
 module SpreeCmCommissioner
   class TripStop < Base
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
+
     acts_as_list column: :sequence, scope: :trip_id
 
     belongs_to :trip, class_name: 'SpreeCmCommissioner::Trip', optional: false

data/app/models/spree_cm_commissioner/user_decorator.rb

@@ -59,6 +59,10 @@ module SpreeCmCommissioner
       base.store_public_metadata :primary_service_type, :string
       base.store_public_metadata :qr_data_version, :integer, default: 1
       base.store_public_metadata :qr_data_invalidated_at, :datetime
+      # Bumped on both mint and consume by SpreeCmCommissioner::CrossAppHandoffTokens — minting
+      # invalidates any earlier, not-yet-consumed token; consuming invalidates the token just used,
+      # so a replay within its TTL fails. See CrossAppHandoffTokens::Encode/Decode.
+      base.store_public_metadata :cross_app_handoff_version, :integer, default: 0
       base.store_public_metadata :branch_ids, :array, default: []
 
       # Why the block reason lives in metadata rather than its own column: it is display-only text

data/app/models/spree_cm_commissioner/variant_decorator.rb

@@ -6,6 +6,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::VariantOptionsConcern
       base.include SpreeCmCommissioner::KycBitwise
       base.include SpreeCmCommissioner::Integrations::IntegrationMappable
+      base.include SpreeCmCommissioner::VariantMetadata
 
       base.after_commit :update_vendor_price
       base.validate     :validate_option_types
@@ -80,6 +81,10 @@ module SpreeCmCommissioner
       delivery_option == 'delivery'
     end
 
+    def inventory_external_wins?
+      vendor&.integration&.inventory_external_wins?(self) || false
+    end
+
     def non_digital_ecommerce?
       !digital? && ecommerce?
     end

data/app/models/spree_cm_commissioner/vehicle.rb

@@ -1,6 +1,7 @@
 module SpreeCmCommissioner
   class Vehicle < Base
     include SpreeCmCommissioner::VehicleKind
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
 
     belongs_to :vendor, class_name: 'Spree::Vendor'
     belongs_to :vehicle_type, class_name: 'SpreeCmCommissioner::VehicleType'
@@ -13,6 +14,8 @@ module SpreeCmCommissioner
     validates :name, presence: true
     validates :license_plate, uniqueness: true, allow_blank: true
 
+    has_one :seat_layout, through: :vehicle_type
+
     self.whitelisted_ransackable_attributes = %w[name license_plate kind]
 
     def display_name

data/app/models/spree_cm_commissioner/vehicle_type.rb

@@ -2,6 +2,7 @@ module SpreeCmCommissioner
   class VehicleType < Base
     include SpreeCmCommissioner::StoreMetadata
     include SpreeCmCommissioner::VehicleKind
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
 
     # This model has no seat_layout column (polymorphic association), so we store the preload_seat_layout_id ID in public_metadata.
     # This lets us check if a seat layout exists without triggering a database query.

data/app/models/spree_cm_commissioner/vendor_decorator.rb

@@ -33,6 +33,7 @@ module SpreeCmCommissioner
       base.has_many :nearby_places, -> { order(position: :asc) }, class_name: 'SpreeCmCommissioner::VendorPlace', dependent: :destroy
 
       base.has_many :stock_items, through: :variants, class_name: 'Spree::StockItem'
+      base.has_many :currency_rates, class_name: 'SpreeCmCommissioner::CurrencyRate', dependent: :destroy
 
       base.has_many :taxon_vendors, class_name: 'SpreeCmCommissioner::TaxonVendor'
       base.has_many :taxons, through: :taxon_vendors
@@ -104,6 +105,7 @@ module SpreeCmCommissioner
       base.has_many :boarding_trip_stops, through: :trips, class_name: 'SpreeCmCommissioner::TripStop', source: :boarding_trip_stops
       base.has_many :drop_off_trip_stops, through: :trips, class_name: 'SpreeCmCommissioner::TripStop', source: :drop_off_trip_stops
       base.has_many :pricing_models, class_name: 'SpreeCmCommissioner::PricingModel', foreign_key: :vendor_id, dependent: :destroy
+      base.has_many :orders, -> { distinct }, through: :variants, source: :orders
 
       base.has_many :agency_categories, -> { where(kind: :agency_category) }, class_name: 'Spree::Taxon', foreign_key: :vendor_id
 
@@ -248,6 +250,21 @@ module SpreeCmCommissioner
 
     delegate :present?, to: :tenant, prefix: true
 
+    # Returns the exchange rate between two currencies
+    # If no direct rate exists, calculates the inverse rate from the reverse pair
+    # Returns 1.0 for identical currencies, nil if no rate is found
+    def exchange_rate(from_currency, to_currency)
+      return 1.0 if from_currency == to_currency
+
+      pair = currency_rates.by_pair(from_currency, to_currency).first
+      return pair.rate if pair.present?
+
+      reverse_pair = currency_rates.by_pair(to_currency, from_currency).first
+      return (1.0 / reverse_pair.rate).round(6) if reverse_pair.present?
+
+      nil
+    end
+
     def validate_sellable_product_types
       valid_types = SpreeCmCommissioner::ProductType::PRODUCT_TYPES.map(&:to_s)
       return if sellable_product_types.all? { |type| valid_types.include?(type.to_s) }

data/app/models/spree_cm_commissioner/vendor_place.rb

@@ -1,5 +1,7 @@
 module SpreeCmCommissioner
   class VendorPlace < Base
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
+
     enum place_type: { venue: 0, branch: 1, stop: 2, location: 3 }
     acts_as_list scope: :vendor
 

data/app/overrides/spree/admin/orders/index/line_items_row.html.erb.deface

@@ -0,0 +1,14 @@
+<!-- insert_after "[data-hook='admin_orders_index_rows']" -->
+
+<tr>
+  <td colspan="100" class="p-0 border-top-0">
+    <div class="collapse" id="line-items-collapse-<%= order.id %>">
+      <div class="mb-3 overflow-hidden border rounded-lg">
+        <%= turbo_frame_tag "order_#{order.id}_line_items",
+              src: line_items_admin_order_path(order), loading: 'lazy' do %>
+          <div class="p-3 text-center text-muted"><%= Spree.t(:loading) %>&hellip;</div>
+        <% end %>
+      </div>
+    </div>
+  </td>
+</tr>

data/app/overrides/spree/admin/orders/index/row_actions.html.erb.deface

@@ -0,0 +1,17 @@
+<!-- replace "[data-hook='admin_orders_index_row_actions']" -->
+
+<td class='actions' data-hook="admin_orders_index_row_actions">
+  <span class="d-flex justify-content-end align-items-center">
+    <%= link_to_edit_url cart_admin_order_path(order), title: "admin_edit_#{dom_id(order)}", no_text: true if can?(:edit, order) %>
+
+    <%= link_to_with_icon 'credit-card.svg', Spree.t(:payments), admin_order_payments_path(order),
+      class: 'icon_link btn btn-light btn-sm ml-1', no_text: true if can?(:index, Spree::Payment) %>
+
+    <button type="button" data-toggle="collapse" data-target="#line-items-collapse-<%= order.id %>"
+            aria-expanded="false" aria-controls="line-items-collapse-<%= order.id %>"
+            class="pl-3 ml-1 btn btn-sm btn-light">
+      Line Items
+      <%= svg_icon(name: 'chevron-down.svg', classes: 'icon', width: 12, height: 12) %>
+    </button>
+  </span>
+</td>

data/app/overrides/spree/admin/shared/sub_menu/_configuration/menu_items.html.erb.deface

@@ -3,3 +3,8 @@
 <%= configurations_sidebar_menu_item(Spree.t(:icons), spree.admin_vectors_icons_path) if can? :manage, Spree::Product %>
 <%= configurations_sidebar_menu_item(Spree.t(:exports), spree.admin_exports_path) if can? :manage, SpreeCmCommissioner::Export %>
 <%= configurations_sidebar_menu_item(Spree.t(:imports), spree.admin_imports_path) if can? :manage, SpreeCmCommissioner::Import %>
+<%= configurations_sidebar_menu_item(
+  Spree.t(:service_fee_rules),
+  spree.admin_service_fee_rules_path(status: 'active'),
+  { is_selected: controller.controller_name == 'service_fee_rules' }
+) if can? :manage, SpreeCmCommissioner::ServiceFeeRule %>

data/app/queries/spree_cm_commissioner/users_by_event_fetcher_query.rb

@@ -1,17 +1,16 @@
 module SpreeCmCommissioner
   class UsersByEventFetcherQuery
-    attr_reader :taxon_id
+    attr_reader :event_id
 
-    def initialize(taxon_id)
-      @taxon_id = taxon_id
+    def initialize(event_id:)
+      @event_id = event_id
     end
 
+    # Fetches distinct users with a completed order containing a line item for the given event(s)
     def call
-      classifications = Spree::Classification.where(taxon_id: @taxon_id)
-      product_ids = classifications.pluck(:product_id)
-      Spree::User.joins(orders: { line_items: :variant })
+      Spree::User.joins(orders: :line_items)
                  .where(spree_orders: { state: 'complete' })
-                 .where(spree_variants: { product_id: product_ids })
+                 .where(spree_line_items: { event_id: @event_id })
                  .distinct
     end
   end

data/app/serializables/spree_cm_commissioner/item_availability_sync.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  class ItemAvailabilitySync
+    attr_reader :id, :last_sync_at
+
+    def initialize(id:, last_sync_at:)
+      @id = id
+      @last_sync_at = last_sync_at
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/service_fee_rule_serializer.rb

@@ -0,0 +1,17 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class ServiceFeeRuleSerializer < BaseSerializer
+          attribute :type_name do |rule|
+            rule.class.name.underscore
+          end
+
+          attribute :fee_description
+
+          has_one :calculator, if: proc { |rule| rule.respond_to?(:calculator) }
+        end
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@ module Spree
   module V2
     module Storefront
       class HomepageSectionSerializer < BaseSerializer
-        attributes :id, :title, :segments, :description, :active, :position, :preview, :created_at, :updated_at
+        attributes :id, :title, :segments, :mini_apps, :description, :active, :position, :preview, :created_at, :updated_at
         has_many :homepage_section_relatables
       end
     end