spree_cm_commissioner 2.13.4 → 2.13.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 565fc705e24c32c2f3bd35aad88607d80d7f26b1bab3ff62dc64e2890202ed9a
-  data.tar.gz: b6647ca2838265f710f999389157765f24ba1baf92369521aab95a711779a0d9
+  metadata.gz: 9473bef71175dc42b69c1959ac56827e1ca0ef2b6c13205ed2c83793e678a21f
+  data.tar.gz: 314a9fbe0dbc6fe925f435b3eaeef9d737689f81fb7d95e631bbcf10a2e3e8bf
 SHA512:
-  metadata.gz: 36a8d1f75f387fb33ab1d394ee91e61ce6c1179bbf2323352f1d56e3bbb303942d57af72933910e8017f184dcf0a24174a12f70ec4a69e42309cbec47fe9cdd7
-  data.tar.gz: d7dc21e3383b9784c9b0cef12c354f4a3d4d3535fe122b666b8abdd3b4e4fea4660f321ada830e83fdb409ebd8d2d91ed9fa6295b1801371d803475334431860
+  metadata.gz: fa509b4c09684a80915bca9927228aa41de193821593d00f84da4cd1bb2f2b0d5034146d9c52e4dec654ad57092ac87273771be63841b66546cb1a1b63e0077d
+  data.tar.gz: f04d83d04ce10ebb051931a0bde85c690e279ac08d18e90b3be9e2f14721992c9e04096ef1eab051e1dde8b81ba6ea6aef356ca77422ac27ecb05aebf7f2e5c8

data/.env.example

@@ -86,3 +86,8 @@ PAYMENT_INCOMPLETE_NOTIFICATION_DELAY_IN_MINUTES=5  # Delay before notifying a c
 
 # See: app/jobs/spree_cm_commissioner/telegram_alerts/order_integrity_check_job.rb
 ORDER_INTEGRITY_TELEGRAM_ALERT_ENABLED="no"  # Set to yes to enable the order integrity Telegram alert job (off by default to avoid flooding Telegram rate limits during traffic spikes)
+
+# See: app/models/concerns/spree_cm_commissioner/product_type.rb
+PRE_INVENTORY_DAYS_TRANSIT=180  # How many days ahead inventory items are pre-generated for transit variants
+PRE_INVENTORY_DAYS_ACCOMMODATION=365  # How many days ahead inventory items are pre-generated for accommodation variants
+PRE_INVENTORY_DAYS_SERVICE=180  # How many days ahead inventory items are pre-generated for service variants

data/Gemfile.lock

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

data/app/controllers/spree/admin/inventory_items_controller.rb

@@ -59,6 +59,17 @@ module Spree
         redirect_back fallback_location: admin_product_stock_managements_path(@product)
       end
 
+      # PATCH /products/:slug/inventory_items/bulk_update_closed
+      #
+      # Ids travel in the form body, not the query string: a range across a year can be hundreds of ids.
+      def bulk_update_closed
+        closed = ActiveModel::Type::Boolean.new.cast(params[:closed])
+        count = @product.inventory_items.where(id: params[:inventory_item_ids]).update_all(closed: closed, updated_at: Time.current) # rubocop:disable Rails/SkipsModelValidations
+
+        flash[:success] = "#{closed ? 'Closed' : 'Reopened'} #{count} inventory items for sale"
+        redirect_back fallback_location: admin_product_stock_managements_path(@product)
+      end
+
       # PATCH /products/:slug/inventory_items/bulk_reset?inventory_item_ids=1,2,3
       def bulk_reset
         inventory_item_ids = params[:inventory_item_ids]

data/app/controllers/spree/admin/payment_fee_rules_controller.rb

@@ -0,0 +1,76 @@
+module Spree
+  module Admin
+    # Same CRUD as ServiceFeeRulesController (scope picker, tenant dropdown, calculator partial),
+    # plus the payment method a rule applies to.
+    class PaymentFeeRulesController < Spree::Admin::ResourceController
+      helper SpreeCmCommissioner::Admin::FeeRulesHelper
+      helper_method :selected_tenant
+
+      before_action :load_data
+
+      def index
+        @search = model_class.ransack(params[:q])
+        @status = %w[active inactive].include?(params[:status]) ? params[:status] : 'all'
+
+        scope = @search.result.includes(:payment_method, :ruleable, :calculator, :tenant)
+        scope = scope.where(active: true) if @status == 'active'
+        scope = scope.where(active: false) if @status == 'inactive'
+        # Same tenant semantics as ServiceFeeRulesController#index.
+        scope = scope.where(tenant_id: selected_tenant&.id)
+
+        @payment_fee_rules = scope.order(ruleable_type: :asc, ruleable_id: :asc, payment_method_id: :asc, currency: :asc)
+                                  .page(params[:page])
+                                  .per(25)
+      end
+
+      # See ServiceFeeRulesController#build_resource: tenant_id comes from the URL only.
+      def build_resource
+        model_class.new(tenant_id: params[:tenant_id].presence)
+      end
+
+      private
+
+      def load_data
+        @calculators = model_class.available_calculator_types.sort_by(&:name)
+        @tenants ||= SpreeCmCommissioner::Tenant.order(:name)
+        @payment_methods = Spree::PaymentMethod.includes(:vendor).order(:name)
+        @currencies = (current_store.supported_currencies_list.map(&:iso_code) | [@object&.currency]).compact.sort
+      end
+
+      def selected_tenant
+        return @selected_tenant if defined?(@selected_tenant)
+
+        @selected_tenant = params[:tenant_id].presence && SpreeCmCommissioner::Tenant.find_by(id: params[:tenant_id])
+      end
+
+      def model_class
+        SpreeCmCommissioner::PaymentFeeRule
+      end
+
+      def object_name
+        'spree_cm_commissioner_payment_fee_rule'
+      end
+
+      def collection_url
+        admin_payment_fee_rules_url
+      end
+
+      def location_after_save
+        edit_admin_payment_fee_rule_path(@object)
+      end
+
+      # tenant_id is deliberately excluded -- see build_resource.
+      def permitted_resource_params
+        params.require(:spree_cm_commissioner_payment_fee_rule).permit(
+          :payment_method_id,
+          :ruleable_type,
+          :ruleable_id,
+          :active,
+          :currency,
+          :calculator_type,
+          calculator_attributes: %i[id preferred_percent preferred_flat_amount]
+        )
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/service_fee_rules_controller.rb

@@ -1,6 +1,7 @@
 module Spree
   module Admin
     class ServiceFeeRulesController < Spree::Admin::ResourceController
+      helper SpreeCmCommissioner::Admin::FeeRulesHelper
       helper_method :selected_tenant
 
       before_action :load_data

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

@@ -0,0 +1,48 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        # GET /api/v2/storefront/cart_payment_fees?payment_method_ids[]=1&payment_method_ids[]=2
+        #
+        # Payment fee each requested payment method would add to the current cart. Order-scoped
+        # and uncached on purpose: the answer depends on line items and applied store credit, both
+        # of which change on the payment screen. The client skips methods whose catalog entry says
+        # `fee_configured: false`, so carts with no fees configured never hit this.
+        class CartPaymentFeesController < Spree::Api::V2::ResourceController
+          include OrderConcern
+
+          before_action :ensure_order
+
+          # override
+          def index
+            render_serialized_payload do
+              collection_serializer.new(collection).serializable_hash
+            end
+          end
+
+          # override
+          def collection
+            @collection ||= requested_payment_methods.map do |payment_method|
+              SpreeCmCommissioner::PaymentFees::Preview.call(order: spree_current_order, payment_method: payment_method)
+                                                       .value[:payment_fee_preview]
+            end
+          end
+
+          # override
+          def collection_serializer
+            SpreeCmCommissioner::V2::Storefront::PaymentFeePreviewSerializer
+          end
+
+          private
+
+          # Ids the order can't actually pay with are dropped rather than rejected, so a stale client
+          # list (e.g. a method disabled since the catalog was cached) still gets the rest.
+          def requested_payment_methods
+            ids = Array(params[:payment_method_ids]).map(&:to_s)
+            spree_current_order.available_payment_methods.select { |pm| ids.include?(pm.id.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,8 @@ module Spree
         class SeatLayoutsController < Spree::Api::V2::ResourceController
           # GET /api/v2/storefront/seat_layouts/:id
           # - include_details=true|false (optional, default: true)
+          #
+          # Always returns `product_ids` (see SeatLayout#product_ids).
           def show
             render_serialized_payload { serialize_resource(resource) }
           end
@@ -70,7 +72,7 @@ module Spree
 
           # override
           def serializer_params
-            super.merge(include_details: include_details?)
+            super.merge(include_details: include_details?, include_product_ids: action_name == 'show')
           end
 
           # default return true

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

@@ -0,0 +1,43 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        # See Spree::Api::V2::Storefront::CartPaymentFeesController.
+        class CartPaymentFeesController < BaseController
+          include Spree::Api::V2::Storefront::OrderConcern
+
+          before_action :ensure_order
+
+          # override
+          def index
+            render_serialized_payload do
+              collection_serializer.new(collection).serializable_hash
+            end
+          end
+
+          # override
+          def collection
+            @collection ||= requested_payment_methods.map do |payment_method|
+              SpreeCmCommissioner::PaymentFees::Preview.call(order: spree_current_order, payment_method: payment_method)
+                                                       .value[:payment_fee_preview]
+            end
+          end
+
+          # override
+          def collection_serializer
+            SpreeCmCommissioner::V2::Storefront::PaymentFeePreviewSerializer
+          end
+
+          private
+
+          # Ids the order can't actually pay with are dropped rather than rejected, so a stale client
+          # list (e.g. a method disabled since the catalog was cached) still gets the rest.
+          def requested_payment_methods
+            ids = Array(params[:payment_method_ids]).map(&:to_s)
+            spree_current_order.available_payment_methods.select { |pm| ids.include?(pm.id.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module SpreeCmCommissioner
+  module Admin
+    # Shared by the service fee and payment fee rule lists: the Scope column links to what the
+    # rule is scoped to (the rule itself is opened with the row's edit action).
+    module FeeRulesHelper
+      def fee_rule_scope_link(rule)
+        path = fee_rule_scope_path(rule)
+        path ? link_to(rule.scope_label, path) : rule.scope_label
+      end
+
+      private
+
+      def fee_rule_scope_path(rule)
+        case rule.ruleable
+        when Spree::Product then spree.edit_admin_product_path(rule.ruleable)
+        when Spree::Taxon then spree.edit_admin_taxonomy_taxon_path(rule.ruleable.taxonomy_id, rule.ruleable.id)
+        when Spree::Vendor then spree.edit_admin_vendor_path(rule.ruleable)
+        when nil then rule.tenant ? spree.edit_admin_tenant_path(rule.tenant) : nil
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,8 @@ module SpreeCmCommissioner
       # line item changes between steps.
       state_machine.before_transition to: :payment, do: :create_service_fee_charge!
       state_machine.before_transition from: :address, do: :create_service_fee_charge!
+      state_machine.before_transition to: :payment, do: :clear_stale_payment_fee!
+      state_machine.before_transition from: :address, do: :clear_stale_payment_fee!
 
       # Fails fast, before any of the other before_transition/around_transition work below runs
       # (external-system unstock, Redis unstock, notifications, ...), when the inventory hold has

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

@@ -0,0 +1,36 @@
+module SpreeCmCommissioner
+  # "10% + $0.25" fee shape shared by ServiceFeePercent and PaymentFeePercent. Lives outside
+  # SpreeCmCommissioner::Calculators on purpose: PricingAction.available_calculator_types lists
+  # every constant in that namespace, and a module there would show up as a pickable calculator
+  # type. The flat part is named like the *FlatAmount calculators' preference so admins see one
+  # term; each including calculator decides what it's multiplied by (per unit for service fees,
+  # once per payment for payment fees).
+  module PercentFeeCalculable
+    extend ActiveSupport::Concern
+
+    included do
+      preference :percent, :decimal, default: 0
+      preference :flat_amount, :decimal, default: 0
+    end
+
+    def fee_description(currency:)
+      percent = "#{preferred_percent.to_d.round(2).to_s('F')}%"
+      return percent unless preferred_flat_amount.to_d.positive?
+
+      flat = Spree::Money.new(preferred_flat_amount, currency: currency).to_s
+      return flat if preferred_percent.to_d.zero?
+
+      Spree.t(:fee_percent_plus_flat, percent: percent, flat: flat)
+    end
+
+    private
+
+    # Nothing to charge on a zero base (a free line item, or store credit covering the order),
+    # so the flat part isn't added on its own there either.
+    def percent_plus_flat(base, flat)
+      return 0 unless base.to_d.positive?
+
+      (base * preferred_percent / 100) + flat
+    end
+  end
+end

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

@@ -7,7 +7,11 @@ module SpreeCmCommissioner
 
     PRODUCT_TYPES = %i[accommodation service ecommerce transit show_episode vote_package advertisement].freeze
     PERMANENT_STOCK_PRODUCT_TYPES = %w[accommodation service transit].freeze
-    PRE_INVENTORY_DAYS = { 'transit' => 90, 'accommodation' => 365, 'service' => 30 }.freeze
+    PRE_INVENTORY_DAYS = {
+      'transit' => ENV.fetch('PRE_INVENTORY_DAYS_TRANSIT', 180).to_i,
+      'accommodation' => ENV.fetch('PRE_INVENTORY_DAYS_ACCOMMODATION', 365).to_i,
+      'service' => ENV.fetch('PRE_INVENTORY_DAYS_SERVICE', 180).to_i
+    }.freeze
 
     included do
       enum product_type: PRODUCT_TYPES if table_exists? && column_names.include?('product_type')

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

@@ -0,0 +1,129 @@
+module SpreeCmCommissioner
+  # Shared scoping for fee rules that resolve product -> event -> vendor -> tenant/global
+  # (ServiceFeeRule, PaymentFeeRule). Each including model keeps its own uniqueness
+  # validation, since what makes a rule unique differs (PaymentFeeRule adds payment_method_id).
+  module ScopedFeeRule
+    extend ActiveSupport::Concern
+
+    ALLOWED_RULEABLE_TYPES = %w[Spree::Product Spree::Taxon Spree::Vendor].freeze
+
+    included do
+      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? }
+
+      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)
+      }
+    end
+
+    # "Name (slug)" for a product/event/vendor, so same-named records can be told apart in the
+    # admin scope-target picker. Events (taxons) show their permalink first: that's what the
+    # picker searches them by, and it reads clearer than the taxon's generated slug.
+    def self.ruleable_label(record)
+      name = record.respond_to?(:pretty_name) ? record.pretty_name : record.try(:name)
+      slug = record.try(:permalink).presence || record.try(:slug).presence
+      slug ? "#{name} (#{slug})" : name.to_s
+    end
+
+    class_methods do
+      # Walks product -> event -> vendor -> global within `relation`, 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.
+      #
+      # Runs outside MultiTenant scoping: tenant API requests set a current tenant, which would
+      # filter every query to `tenant_id = <tenant>` and so skip product/event/vendor rules (they
+      # never store a tenant_id). Tenancy is handled explicitly above instead.
+      def resolve_scoped(line_item:, currency:, relation: all)
+        MultiTenant.without do
+          ruleables_for(line_item).each do |ruleable|
+            rule = relation.active_for(ruleable: ruleable, currency: currency).first
+            return rule if rule.present?
+          end
+
+          relation.active_for_tenant(tenant_id: vendor_for(line_item)&.tenant_id, currency: currency).first
+        end
+      end
+
+      # Compacted because active_for(ruleable: nil) means "ruleable-less", i.e. the global/tenant
+      # rows: a line item without an event would otherwise match a global rule before ever
+      # checking its vendor.
+      def ruleables_for(line_item)
+        [line_item.product, line_item.event, vendor_for(line_item)].compact
+      end
+
+      def vendor_for(line_item)
+        product = line_item.product
+        product.respond_to?(:vendor) ? product.vendor : nil
+      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_scoped), 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
+
+    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/adjustment_decorator.rb

@@ -4,6 +4,7 @@ module SpreeCmCommissioner
       base.belongs_to :payable, polymorphic: true, optional: true
       base.scope :pricing_action, -> { where(source_type: 'SpreeCmCommissioner::PricingAction') }
       base.scope :service_fee, -> { where(source_type: 'SpreeCmCommissioner::ServiceFeeRule') }
+      base.scope :payment_fee, -> { where(source_type: 'SpreeCmCommissioner::PaymentFeeRule') }
       base.whitelisted_ransackable_attributes |= %w[payable_id]
     end
 

data/app/models/spree_cm_commissioner/calculators/payment_fee_flat_amount.rb

@@ -0,0 +1,21 @@
+module SpreeCmCommissioner
+  module Calculators
+    class PaymentFeeFlatAmount < Spree::Calculator
+      preference :flat_amount, :decimal, default: 0
+
+      def self.description
+        Spree.t(:payment_fee_flat_amount)
+      end
+
+      # Once per payment, not per unit: providers bill per transaction. Nothing to charge when
+      # store credit covers the whole order and no gateway payment happens.
+      def compute(base)
+        base.to_d.positive? ? preferred_flat_amount : 0
+      end
+
+      def fee_description(currency:)
+        Spree::Money.new(preferred_flat_amount, currency: currency).to_s
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/calculators/payment_fee_percent.rb

@@ -0,0 +1,17 @@
+module SpreeCmCommissioner
+  module Calculators
+    class PaymentFeePercent < Spree::Calculator
+      include SpreeCmCommissioner::PercentFeeCalculable
+
+      def self.description
+        Spree.t(:payment_fee_percent)
+      end
+
+      # `base` is the share of the gateway amount this rule covers (see PaymentFees::Preview),
+      # not a line item: providers bill per transaction, so the flat part applies once per payment.
+      def compute(base)
+        percent_plus_flat(base.to_d, preferred_flat_amount)
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/calculators/service_fee_flat_amount.rb

@@ -12,6 +12,10 @@ module SpreeCmCommissioner
       def compute(line_item)
         preferred_flat_amount * line_item.quantity
       end
+
+      def fee_description(currency:)
+        Spree::Money.new(preferred_flat_amount, currency: currency).to_s
+      end
     end
   end
 end

data/app/models/spree_cm_commissioner/calculators/service_fee_percent.rb

@@ -1,7 +1,7 @@
 module SpreeCmCommissioner
   module Calculators
     class ServiceFeePercent < Spree::Calculator
-      preference :percent, :decimal, default: 0
+      include SpreeCmCommissioner::PercentFeeCalculable
 
       def self.description
         Spree.t(:service_fee_percent)
@@ -12,8 +12,11 @@ module SpreeCmCommissioner
       # Spree::TaxRate.store_pre_tax_amount running for this line item, so it would make
       # service-fee computation order-dependent on tax having already run. discounted_amount
       # is a live computed value (amount + taxable_adjustment_total) with no such dependency.
+      #
+      # The flat part is per unit, same as ServiceFeeFlatAmount, so "10% + $0.25" adds $0.25 per
+      # ticket regardless of how tickets are grouped into lines.
       def compute(line_item)
-        line_item.discounted_amount * preferred_percent / 100
+        percent_plus_flat(line_item.discounted_amount, preferred_flat_amount * line_item.quantity)
       end
     end
   end

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -109,6 +109,10 @@ module SpreeCmCommissioner
     # This method is only used when admin update stock
     def adjust_quantity!(quantity)
       with_lock do
+        # Seed a cold Redis key from the DB value before applying the delta: adjust_quantity_in_redis treats a
+        # missing key as 0, so it would otherwise cache only the delta (e.g. 1 for a row the DB holds at 3).
+        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.
@@ -170,12 +174,13 @@ module SpreeCmCommissioner
       inventory_date.nil? || inventory_date >= Time.zone.today
     end
 
-    # 1 year expiry, whether the inventory item is permanent stock or not.
-    #
-    # Why even for permanent stock? Because if we expire it too soon (e.g. right after inventory_date),
-    # admin usually still need to look up past/old inventory items or adjust stock when needed.
+    # Dated keys expire a week after their date, or a day from now for an old date touched later. Expiring
+    # is safe: CachedInventoryItemsBuilder re-warms any cold key from the DB, past dates included.
     def redis_expired_in
-      31_536_000
+      return 1.year.to_i if inventory_date.nil?
+
+      expires_at = [inventory_date.end_of_day + 7.days, 1.day.from_now].max
+      (expires_at - Time.zone.now).to_i
     end
   end
 end

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -21,7 +21,7 @@ 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.money_methods :service_fee_total, :payment_fee_total
 
       base.validates :promo_total, base::MONEY_VALIDATION
       base.validates :phone_number, presence: true, if: :require_phone_number
@@ -166,6 +166,17 @@ module SpreeCmCommissioner
       SpreeCmCommissioner::ServiceFeeRule.adjust(self, line_items)
     end
 
+    # A payment fee is only correct for the total it was computed on, so one left over from an
+    # earlier payment attempt is dropped whenever checkout steps re-run. Skipped once a gateway
+    # payment exists: its amount already includes the fee, and clearing it would make the order
+    # total smaller than what that payment charges.
+    def clear_stale_payment_fee!
+      return unless adjustments.payment_fee.exists?
+      return if payments.valid.any? { |payment| !payment.store_credit? }
+
+      SpreeCmCommissioner::PaymentFees::Clear.call(order: self)
+    end
+
     # overrided
     def payment_required?
       return false if need_confirmation?

data/app/models/spree_cm_commissioner/order_updater_decorator.rb

@@ -12,10 +12,14 @@ module SpreeCmCommissioner
     def update_adjustment_total
       super
       order.service_fee_total = line_items.sum(:service_fee_total)
+
+      # Order-level adjustments (see PaymentFees::Apply) are already in adjustment_total via
+      # core's `adjustments.eligible.sum(:amount)`; this is the display-only breakdown.
+      order.payment_fee_total = adjustments.payment_fee.eligible.sum(:amount)
     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
+    # rather than calling super + a second update_columns for the fee totals, 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.
@@ -33,6 +37,7 @@ module SpreeCmCommissioner
         promo_total: order.promo_total,
         total: order.total,
         service_fee_total: order.service_fee_total,
+        payment_fee_total: order.payment_fee_total,
         updated_at: Time.current
       )
     end