spree_cm_commissioner 2.13.4 → 2.13.5

data/app/models/spree_cm_commissioner/payment_fee_rule.rb

@@ -0,0 +1,97 @@
+module SpreeCmCommissioner
+  class PaymentFeeRule < SpreeCmCommissioner::Base
+    include SpreeCmCommissioner::ScopedFeeRule
+    include Spree::AdjustmentSource
+    include Spree::CalculatedAdjustments
+
+    # Same reason as ServiceFeeRule: without class_name Rails looks for
+    # SpreeCmCommissioner::Adjustment.
+    has_many :adjustments, as: :source, class_name: 'Spree::Adjustment'
+
+    # optional: false spelled out because Spree turns off belongs_to_required_by_default; without
+    # it a blank admin form reaches the NOT NULL column and raises instead of showing a form error.
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', optional: false
+
+    # One rule per (payment method, scope, currency), active or not: `active` is an on/off switch,
+    # not a way to keep old versions around. A duplicate is pointed at the existing rule instead
+    # (see #duplicate_rule and the admin form).
+    validates :currency,
+              uniqueness: {
+                scope: %i[payment_method_id ruleable_type ruleable_id tenant_id],
+                case_sensitive: false,
+                message: lambda { |object, _data|
+                  I18n.t('payment_fee.rules.rule_already_exists_for_scope',
+                         payment_method: object.payment_method&.name,
+                         scope_type: object.ruleable_type_label,
+                         currency: object.currency
+                        )
+                }
+              }
+
+    scope :for_payment_method, -> (payment_method) { where(payment_method_id: payment_method) }
+
+    def duplicate_rule
+      self.class.where.not(id: id).find_by(
+        payment_method_id: payment_method_id, ruleable_type: ruleable_type, ruleable_id: ruleable_id,
+        tenant_id: tenant_id, currency: currency
+      )
+    end
+
+    # Caches on the payment method whether any active rule exists for it, at any scope, so the
+    # catalog can serialize fee_configured without a query. Coarser than "could reach this vendor"
+    # (a shared store method is flagged for every vendor once one vendor has a fee), but `false`
+    # still guarantees no fee, which is all the client relies on.
+    after_commit :sync_payment_method_fee_configured!
+
+    def self.resolve_for(line_item:, payment_method:, currency:)
+      resolve_scoped(line_item: line_item, currency: currency, relation: for_payment_method(payment_method))
+    end
+
+    def self.available_calculator_types
+      [SpreeCmCommissioner::Calculators::PaymentFeePercent, SpreeCmCommissioner::Calculators::PaymentFeeFlatAmount]
+    end
+
+    # Required by Spree::AdjustmentSource, but PaymentFees::Apply never goes through it: it stores
+    # the amounts PaymentFees::Preview computed, as closed adjustments, so this is only reached if
+    # something reopens one. Recomputing here would need the whole order's gateway split, so keep
+    # whatever was stored.
+    def compute_amount(adjustable)
+      adjustments.find_by(adjustable: adjustable)&.amount || 0
+    end
+
+    def fee_description
+      return Spree.t(:service_fee_rule_not_configured) if calculator.nil?
+      return Spree.t(:payment_fee_mode_none) if no_fee?
+
+      calculator.fee_description(currency: currency)
+    end
+
+    # An explicit zero rule: how a narrower scope opts out of a broader rule's fee.
+    def no_fee?
+      case calculator
+      when Calculators::PaymentFeePercent
+        calculator.preferred_percent.to_d.zero? && calculator.preferred_flat_amount.to_d.zero?
+      when Calculators::PaymentFeeFlatAmount
+        calculator.preferred_flat_amount.to_d.zero?
+      else
+        true
+      end
+    end
+
+    def label
+      Spree.t(:payment_fee)
+    end
+
+    private
+
+    # Also re-syncs the previous method when a rule moves to another one.
+    def sync_payment_method_fee_configured!
+      ids = [payment_method_id, payment_method_id_previously_was].compact.uniq
+
+      Spree::PaymentMethod.where(id: ids).find_each do |payment_method|
+        payment_method.preload_fee_configured = self.class.active_rules.exists?(payment_method_id: payment_method.id)
+        payment_method.save! if payment_method.changed?
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/payment_method_decorator.rb

@@ -7,6 +7,11 @@ module SpreeCmCommissioner
 
       base.whitelisted_ransackable_attributes = %w[name]
 
+      base.include SpreeCmCommissioner::StoreMetadata
+      # Kept in sync by PaymentFeeRule#sync_payment_method_fee_configured!, so the cached payment
+      # methods catalog can say whether to ask for fee previews without a rules query per request.
+      base.store_private_metadata :preload_fee_configured, :boolean, default: false
+
       # Expose a dedicated class helper so services can call Spree::PaymentMethod.ticket_transfer
       # instead of duplicating lookup/creation logic.
       base.define_singleton_method(:ticket_transfer) do

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

@@ -49,13 +49,15 @@ 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
 
       def cache_inventory(key, inventory_item, db_value, count_in_redis)
+        # Past dates are warmed too: InventoryItem#adjust_quantity! relies on this to seed the key before
+        # applying its delta, and an admin can still edit a past date's stock.
         return count_in_redis.to_i if count_in_redis.present?
-        return db_value unless inventory_item.active?
 
         # Use atomic SET NX to prevent race condition where multiple concurrent reads
         # initialize cache with stale values. Only the first thread wins.

data/app/models/spree_cm_commissioner/seat_layout.rb

@@ -60,6 +60,13 @@ module SpreeCmCommissioner
       seat_sections.where.not(shape_path: nil).exists? || blocks.where.not(shape_path: nil).exists?
     end
 
+    # Products owning the variants this layout's blocks sell. A block references only a variant,
+    # and an event's layouts mix variants from several products, so a client opening a sub-layout
+    # from a guide zone has no other way to know which products to load to make its seats selectable.
+    def product_ids
+      Spree::Variant.where(id: blocks.where.not(variant_id: nil).select(:variant_id)).distinct.order(:product_id).pluck(:product_id)
+    end
+
     private
 
     def sync_seat_layout_id_to_layoutable! # rubocop:disable Metrics/PerceivedComplexity

data/app/models/spree_cm_commissioner/service_fee_rule.rb

@@ -1,7 +1,6 @@
 module SpreeCmCommissioner
   class ServiceFeeRule < SpreeCmCommissioner::Base
-    ALLOWED_RULEABLE_TYPES = %w[Spree::Product Spree::Taxon Spree::Vendor].freeze
-
+    include SpreeCmCommissioner::ScopedFeeRule
     include Spree::AdjustmentSource
     include Spree::CalculatedAdjustments
 
@@ -11,54 +10,26 @@ module SpreeCmCommissioner
     # 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."
+    # One rule per (ruleable, tenant, currency), active or not: `active` is an on/off switch, not a
+    # way to keep old versions around, and a duplicate is pointed at the existing rule instead (see
+    # #duplicate_rule and the admin form). The global rule is a ruleable-less row, so ruleable_type
+    # / ruleable_id are both nil for it; tenant_id nil there means "true platform-wide".
     validates :currency,
               uniqueness: {
-                scope: %i[ruleable_type ruleable_id tenant_id active],
-                conditions: -> { where(active: true) },
+                scope: %i[ruleable_type ruleable_id tenant_id],
                 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)
-    }
+    def duplicate_rule
+      self.class.where.not(id: id).find_by(
+        ruleable_type: ruleable_type, ruleable_id: ruleable_id, tenant_id: tenant_id, currency: currency
+      )
+    end
 
     # 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
@@ -81,33 +52,8 @@ module SpreeCmCommissioner
       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
+      resolve_scoped(line_item: line_item, currency: currency)
     end
 
     # Spree calculators only expose a fixed, hardcoded set of calculable model types
@@ -123,43 +69,12 @@ module SpreeCmCommissioner
       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.
+    # A short, human-readable summary for admin listings, e.g. "10% (min $0.25)" or "$0.25" — so
+    # a rule's actual fee doesn't require opening it to see.
     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
+      return Spree.t(:service_fee_rule_not_configured) if calculator.nil?
 
-    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
+      calculator.respond_to?(:fee_description) ? calculator.fee_description(currency: currency) : calculator.description
     end
 
     protected
@@ -167,17 +82,5 @@ module SpreeCmCommissioner
     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/overrides/spree/admin/shared/_product_tabs/stock_managements.html.erb.deface

@@ -2,5 +2,5 @@
 
 <%= link_to_with_icon 'box-seam.svg',
   Spree.t(:stock_managements),
-  admin_product_stock_managements_url(@product),
+  @product.permanent_stock? ? calendar_admin_product_stock_managements_url(@product) : admin_product_stock_managements_url(@product),
   class: "nav-link #{'active' if current == :stock_managements}" %>

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

@@ -8,3 +8,8 @@
   spree.admin_service_fee_rules_path(status: 'active'),
   { is_selected: controller.controller_name == 'service_fee_rules' }
 ) if can? :manage, SpreeCmCommissioner::ServiceFeeRule %>
+<%= configurations_sidebar_menu_item(
+  Spree.t(:payment_fees),
+  spree.admin_payment_fee_rules_path(status: 'active'),
+  { is_selected: controller.controller_name == 'payment_fee_rules' }
+) if can? :manage, SpreeCmCommissioner::PaymentFeeRule %>

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

@@ -14,7 +14,8 @@ module Spree
                    :pre_tax_item_amount, :display_pre_tax_item_amount, :pre_tax_total, :display_pre_tax_total,
                    :shipment_state, :payment_state, :public_metadata,
                    :phone_number, :intel_phone_number, :country_code, :request_state, :channel,
-                   :service_fee_total, :display_service_fee_total
+                   :service_fee_total, :display_service_fee_total,
+                   :payment_fee_total, :display_payment_fee_total
 
         belongs_to :user, serializer: Spree::V2::Tenant::UserSerializer
         belongs_to :billing_address,

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

@@ -19,6 +19,9 @@ module Spree
 
           pref.blank? || pref[:payment_option].blank? ? payment_method.method_type : pref[:payment_option]
         end
+
+        # Precomputed on fee rule save (PaymentFeeRule#sync_payment_method_fee_configured!).
+        attribute :fee_configured, &:preload_fee_configured?
       end
     end
   end

data/app/serializers/spree_cm_commissioner/api/v2/platform/homepage_section_relatable_options_serializer.rb

@@ -3,6 +3,11 @@ module SpreeCmCommissioner
     module V2
       module Platform
         class HomepageSectionRelatableOptionsSerializer < ::Spree::Api::V2::Platform::BaseSerializer
+          # Used by the fee rule forms' scope-target picker; other callers keep using `name`.
+          attribute :name_with_slug do |object|
+            SpreeCmCommissioner::ScopedFeeRule.ruleable_label(object)
+          end
+
           attribute :name do |object|
             if object.respond_to?(:pretty_name)
               object.pretty_name

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

@@ -11,6 +11,7 @@ module SpreeCmCommissioner
                           :term_accepted_at,
                           :channel, :hold_expires_at,
                           :service_fee_total, :display_service_fee_total,
+                          :payment_fee_total, :display_payment_fee_total,
                           :order_total_after_store_credit, :display_order_total_after_store_credit
 
           base.attribute :has_incomplete_guest_info, &:has_incomplete_guest_info?

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

@@ -8,6 +8,7 @@ module SpreeCmCommissioner
 
         attributes :variant_id,
                    :inventory_date,
+                   :closed,
                    :public_quantity_available
 
         attribute :currency do |_item, params|

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

@@ -0,0 +1,19 @@
+module SpreeCmCommissioner
+  module V2
+    module Storefront
+      class PaymentFeePreviewSerializer < BaseSerializer
+        set_type :payment_fee_preview
+
+        attributes :payment_method_id, :currency, :amount, :order_total_after_store_credit, :fee_description
+
+        attribute :display_amount do |preview|
+          preview.display_amount.to_s
+        end
+
+        attribute :display_order_total_after_store_credit do |preview|
+          preview.display_order_total_after_store_credit.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module SpreeCmCommissioner
+  module V2
+    module Storefront
+      module PaymentMethodSerializerDecorator
+        def self.prepended(base)
+          # Precomputed on fee rule save (PaymentFeeRule#sync_payment_method_fee_configured!).
+          base.attribute :fee_configured, &:preload_fee_configured?
+        end
+      end
+    end
+  end
+end
+
+unless Spree::V2::Storefront::PaymentMethodSerializer.included_modules.include?(SpreeCmCommissioner::V2::Storefront::PaymentMethodSerializerDecorator)
+  Spree::V2::Storefront::PaymentMethodSerializer.prepend(SpreeCmCommissioner::V2::Storefront::PaymentMethodSerializerDecorator)
+end

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

@@ -4,11 +4,19 @@ module SpreeCmCommissioner
       class SeatLayoutSerializer < BaseSerializer
         attributes :name, :status, :width, :height, :guide, :background_svg_url, :background_color
 
+        # Opt-in: TripSerializer embeds this serializer per trip, where an extra query per layout
+        # would N+1 a trip list that never needs it.
+        attribute :product_ids, if: proc { |_, params| params && params[:include_product_ids] == true }
+
         has_many :seat_sections, serializer: SpreeCmCommissioner::V2::Storefront::SeatSectionSerializer,
                                  if: proc { |_, params| params && params[:include_details] == true }
 
         has_many :top_level_blocks, serializer: SpreeCmCommissioner::V2::Storefront::BlockSerializer,
                                     if: proc { |_, params| params && params[:include_details] == true }
+
+        # The record cache is keyed by record only, not params, so a cached entry would replay
+        # whichever include_details/include_product_ids variant was serialized first.
+        cache_options store: nil
       end
     end
   end

data/app/services/spree_cm_commissioner/checkout/add_store_credit_decorator.rb

@@ -0,0 +1,17 @@
+module SpreeCmCommissioner
+  module Checkout
+    module AddStoreCreditDecorator
+      # override: drops any payment fee from an earlier attempt first, otherwise store credit
+      # would be sized against a total that still includes it (outstanding_balance).
+      def call(order:, amount: nil)
+        SpreeCmCommissioner::PaymentFees::Clear.call(order: order) if order.present? && !order.completed?
+
+        super
+      end
+    end
+  end
+end
+
+unless Spree::Checkout::AddStoreCredit.included_modules.include?(SpreeCmCommissioner::Checkout::AddStoreCreditDecorator)
+  Spree::Checkout::AddStoreCredit.prepend(SpreeCmCommissioner::Checkout::AddStoreCreditDecorator)
+end

data/app/services/spree_cm_commissioner/checkout/remove_store_credit_decorator.rb

@@ -0,0 +1,17 @@
+module SpreeCmCommissioner
+  module Checkout
+    module RemoveStoreCreditDecorator
+      # override: the gateway amount the fee was computed on changes with store credit, so the
+      # next FindOrCreate recomputes it from scratch instead of the order carrying a stale one.
+      def call(order:)
+        SpreeCmCommissioner::PaymentFees::Clear.call(order: order) if order.present? && !order.completed?
+
+        super
+      end
+    end
+  end
+end
+
+unless Spree::Checkout::RemoveStoreCredit.included_modules.include?(SpreeCmCommissioner::Checkout::RemoveStoreCreditDecorator)
+  Spree::Checkout::RemoveStoreCredit.prepend(SpreeCmCommissioner::Checkout::RemoveStoreCreditDecorator)
+end

data/app/services/spree_cm_commissioner/payment_fees/apply.rb

@@ -0,0 +1,30 @@
+module SpreeCmCommissioner
+  module PaymentFees
+    # Replaces the order's payment fee with what PaymentFees::Preview computes for
+    # `payment_method`, storing those exact amounts (same pattern as PricingModels::Activate):
+    # never recomputed through PaymentFeeRule#compute_amount, and closed so a later
+    # Adjustment#update! can't change them. Caller is expected to hold the transaction.
+    class Apply
+      prepend ::Spree::ServiceModule::Base
+
+      def call(order:, payment_method:)
+        order.adjustments.payment_fee.delete_all
+
+        preview = Preview.call(order: order, payment_method: payment_method).value[:payment_fee_preview]
+        preview.adjustments.each do |adjustment|
+          order.adjustments.create!(
+            amount: adjustment.amount,
+            source: adjustment.rule,
+            order: order,
+            label: adjustment.rule.label,
+            mandatory: true,
+            state: 'closed'
+          )
+        end
+
+        order.update_with_updater!
+        success(order: order, payment_fee_preview: preview)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/payment_fees/clear.rb

@@ -0,0 +1,15 @@
+module SpreeCmCommissioner
+  module PaymentFees
+    class Clear
+      prepend ::Spree::ServiceModule::Base
+
+      def call(order:)
+        return success(order: order) unless order.adjustments.payment_fee.exists?
+
+        order.adjustments.payment_fee.delete_all
+        order.update_with_updater!
+        success(order: order)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/payment_fees/preview.rb

@@ -0,0 +1,70 @@
+module SpreeCmCommissioner
+  module PaymentFees
+    # Computes, without persisting, the payment fee `payment_method` would add to `order`.
+    #
+    # The base is the gateway amount only (order total minus store credit, minus any payment fee
+    # already applied from an earlier attempt), since that's what the provider bills on. Line items
+    # resolve their own rule (product -> event -> vendor -> tenant/global); when they resolve to
+    # different rules, the gateway amount is split between rules by each group's share of line-item
+    # totals, and the leftover rounding cent goes to the last group so the bases always add up.
+    class Preview
+      prepend ::Spree::ServiceModule::Base
+
+      def call(order:, payment_method:)
+        gateway_amount = gateway_amount_for(order)
+        adjustments = build_adjustments(order, payment_method, gateway_amount)
+        amount = adjustments.sum(BigDecimal(0), &:amount)
+
+        success(
+          payment_fee_preview: PaymentFeePreview.new(
+            payment_method_id: payment_method.id,
+            currency: order.currency,
+            amount: amount,
+            order_total_after_store_credit: gateway_amount + amount,
+            fee_description: adjustments.one? ? adjustments.first.rule.fee_description : nil,
+            adjustments: adjustments
+          )
+        )
+      end
+
+      private
+
+      def gateway_amount_for(order)
+        [order.order_total_after_store_credit - order.payment_fee_total, 0].max
+      end
+
+      def build_adjustments(order, payment_method, gateway_amount)
+        return [] unless gateway_amount.positive?
+
+        groups = order.line_items.group_by do |line_item|
+          PaymentFeeRule.resolve_for(line_item: line_item, payment_method: payment_method, currency: order.currency)
+        end
+        groups.delete(nil)
+        return [] if groups.empty?
+
+        bases = split(gateway_amount, groups, order)
+        groups.keys.zip(bases).filter_map do |rule, base|
+          amount = round(rule.calculator&.compute(base) || 0, order)
+          PaymentFeePreview::Adjustment.new(rule: rule, amount: amount) if amount.positive?
+        end
+      end
+
+      # Items with no rule still pay their share of the gateway amount, just without a fee, so
+      # weights are taken over every line item, not only the ruled ones.
+      def split(gateway_amount, groups, order)
+        all_items_total = order.line_items.sum(&:total)
+        return [gateway_amount] + Array.new(groups.size - 1, 0) unless all_items_total.positive?
+
+        bases = groups.values.map { |items| round(gateway_amount * items.sum(&:total) / all_items_total, order) }
+        return bases if groups.size < order.line_items.size
+
+        bases[-1] += gateway_amount - bases.sum
+        bases
+      end
+
+      def round(amount, order)
+        amount.to_d.round(::Money::Currency.new(order.currency).exponent)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/payments/find_or_create_decorator.rb

@@ -0,0 +1,18 @@
+module SpreeCmCommissioner
+  module Payments
+    module FindOrCreateDecorator
+      # override: applies the selected method's payment fee before the payment is built, so
+      # `amount: order.order_total_after_store_credit` already includes it. Runs inside
+      # FindOrCreate's transaction, so a failed payment save rolls the fee back with it.
+      def find_or_create_payment(order:, params:, payment_method:)
+        SpreeCmCommissioner::PaymentFees::Apply.call(order: order, payment_method: payment_method)
+
+        super
+      end
+    end
+  end
+end
+
+unless Vpago::Payments::FindOrCreate.included_modules.include?(SpreeCmCommissioner::Payments::FindOrCreateDecorator)
+  Vpago::Payments::FindOrCreate.prepend(SpreeCmCommissioner::Payments::FindOrCreateDecorator)
+end