Merge pull request solidusio#6371 from mamhoff/discountable-amounts-by-adjustments

Discountable amounts by adjustments

Author: mamhoff

promotions/app/models/concerns/solidus_promotions/discountable_amount.rb

@@ -2,20 +2,19 @@
 
 module SolidusPromotions
   module DiscountableAmount
-    def discountable_amount
-      amount + current_discounts.sum(&:amount)
-    end
-
     def current_discounts
       @current_discounts ||= []
     end
+    deprecate current_discounts: :previous_lane_discounts, deprecator: Spree.deprecator
 
     def current_discounts=(args)
       @current_discounts = args
     end
+    deprecate :current_discounts=, deprecator: Spree.deprecator
 
     def reset_current_discounts
       @current_discounts = []
     end
+    deprecate :reset_current_discounts=, deprecator: Spree.deprecator
   end
 end

promotions/app/models/concerns/solidus_promotions/discounted_amount.rb

@@ -24,6 +24,8 @@ def initialize
     def discounted_amount
       amount + previous_lanes_discounts.sum(&:amount)
     end
+    # The discountable amount is always equal to the discounted amount.
+    alias_method :discountable_amount, :discounted_amount
 
     # Returns discount objects from the current promotion lane.
     #

promotions/app/models/solidus_promotions/benefit.rb

@@ -97,11 +97,11 @@ def can_discount?(object)
     # @param adjustable [Object] The object to calculate the discount for (e.g., LineItem, Shipment, ShippingRate)
     # @param ... [args, kwargs] Additional arguments passed to the calculator's compute method
     #
-    # @return [SolidusPromotions::ItemDiscount, nil] An ItemDiscount object if a discount applies, nil if the amount is zero
+    # @return [Spree::Adjustment, SolidusPromotions::ShippingRateDiscount, nil] An ItemDiscount object if a discount applies, nil if the amount is zero
     #
     # @example Calculating a discount for a line item
     #   benefit.discount(line_item)
-    #   # => #<SolidusPromotions::ItemDiscount item: #<Spree::LineItem>, amount: -10.00, ...>
+    #   # => #<Spree::Adjustment, adjustable: line_item, amount: -10.00, ...>
     #
     # @see #compute_amount
     # @see #adjustment_label
@@ -175,14 +175,48 @@ def compute_amount(adjustable, ...)
 
     # Builds the localized label for adjustments created by this benefit.
     #
-    # @param adjustable [Object]
-    # @return [String]
-    def adjustment_label(adjustable)
-      I18n.t(
-        "solidus_promotions.adjustment_labels.#{adjustable.class.name.demodulize.underscore}",
-        promotion: SolidusPromotions::Promotion.model_name.human,
-        promotion_customer_label: promotion.customer_label
-      )
+    # This method attempts to use a calculator-specific label method if available,
+    # falling back to a localized string key based on the adjustable's class name.
+    #
+    # ## Calculator Override
+    #
+    # Calculators can provide custom labels by implementing a method named after the
+    # adjustable type. For example, a calculator that discounts line items could
+    # implement `line_item_adjustment_label`:
+    #
+    # @example Custom calculator with adjustment label
+    #   class MyCalculator < Spree::Calculator
+    #     def compute(adjustable, *args)
+    #       # calculation logic
+    #     end
+    #
+    #     def line_item_adjustment_label(line_item, *args)
+    #       "Custom discount for #{line_item.product.name}"
+    #     end
+    #   end
+    #
+    # The method name follows the pattern: `{adjustable_type}_adjustment_label`
+    # where `{adjustable_type}` is the underscored class name of the adjustable
+    # (e.g., `line_item`, `shipment`, `shipping_rate`).
+    #
+    # If the calculator does not respond to the expected method, the benefit will
+    # fall back to using an i18n translation key based on the adjustable's class.
+    #
+    # @param adjustable [Object] the object being discounted (e.g., Spree::LineItem, Spree::Shipment)
+    # @param ... [args, kwargs] additional arguments forwarded to the calculator's label method
+    # @return [String] a localized label suitable for display in adjustments
+    #
+    # @see #adjustment_label_method_for
+    def adjustment_label(adjustable, ...)
+      if calculator.respond_to?(adjustment_label_method_for(adjustable))
+        calculator.send(adjustment_label_method_for(adjustable), adjustable, ...)
+      else
+        I18n.t(
+          "solidus_promotions.adjustment_labels.#{adjustable.class.name.demodulize.underscore}",
+          promotion: SolidusPromotions::Promotion.model_name.human,
+          promotion_customer_label: promotion.customer_label
+        )
+      end
     end
 
     # Partial path used for admin forms for this benefit type.
@@ -277,6 +311,10 @@ def discount_method_for(adjustable)
       :"discount_#{adjustable.class.name.demodulize.underscore}"
     end
 
+    def adjustment_label_method_for(adjustable)
+      :"#{adjustable.class.name.demodulize.underscore}_adjustment_label"
+    end
+
     # Prevents destroying a benefit when it has adjustments on completed orders.
     #
     # Adds an error and aborts the destroy callback chain when such adjustments exist.

promotions/app/models/solidus_promotions/benefits/adjust_line_item.rb

@@ -4,15 +4,10 @@ module SolidusPromotions
   module Benefits
     class AdjustLineItem < Benefit
       def discount_line_item(line_item, ...)
-        amount = compute_amount(line_item, ...)
-        return if amount.zero?
-
-        ItemDiscount.new(
-          item: line_item,
-          label: adjustment_label(line_item),
-          amount: amount,
-          source: self
-        )
+        adjustment = find_adjustment(line_item) || build_adjustment(line_item)
+        adjustment.amount = compute_amount(line_item, ...)
+        adjustment.label = adjustment_label(line_item)
+        adjustment
       end
 
       def possible_conditions
@@ -23,6 +18,21 @@ def level
         :line_item
       end
       deprecate :level, deprecator: Spree.deprecator
+
+      private
+
+      def find_adjustment(line_item)
+        line_item.adjustments.detect do |adjustment|
+          adjustment.source == self
+        end
+      end
+
+      def build_adjustment(line_item)
+        line_item.adjustments.build(
+          order: line_item.order,
+          source: self
+        )
+      end
     end
   end
 end

promotions/app/models/solidus_promotions/benefits/adjust_shipment.rb

@@ -4,27 +4,17 @@ module SolidusPromotions
   module Benefits
     class AdjustShipment < Benefit
       def discount_shipment(shipment, ...)
-        amount = compute_amount(shipment, ...)
-        return if amount.zero?
-
-        ItemDiscount.new(
-          item: shipment,
-          label: adjustment_label(shipment),
-          amount: amount,
-          source: self
-        )
+        adjustment = find_adjustment(shipment) || build_adjustment(shipment)
+        adjustment.amount = compute_amount(shipment, ...)
+        adjustment.label = adjustment_label(shipment)
+        adjustment
       end
 
       def discount_shipping_rate(shipping_rate, ...)
-        amount = compute_amount(shipping_rate, ...)
-        return if amount.zero?
-
-        ItemDiscount.new(
-          item: shipping_rate,
-          label: adjustment_label(shipping_rate),
-          amount: amount,
-          source: self
-        )
+        discount = find_discount(shipping_rate) || build_discount(shipping_rate)
+        discount.amount = compute_amount(shipping_rate, ...)
+        discount.label = adjustment_label(shipping_rate)
+        discount
       end
 
       def possible_conditions
@@ -35,6 +25,31 @@ def level
         :shipment
       end
       deprecate :level, deprecator: Spree.deprecator
+
+      private
+
+      def find_adjustment(shipment)
+        shipment.adjustments.detect do |adjustment|
+          adjustment.source == self
+        end
+      end
+
+      def build_adjustment(shipment)
+        shipment.adjustments.build(
+          order: shipment.order,
+          source: self
+        )
+      end
+
+      def find_discount(shipping_rate)
+        shipping_rate.discounts.detect do |discount|
+          discount.benefit == self
+        end
+      end
+
+      def build_discount(shipping_rate)
+         shipping_rate.discounts.build(benefit: self)
+      end
     end
   end
 end

promotions/app/models/solidus_promotions/benefits/create_discounted_item.rb

@@ -10,7 +10,7 @@ class CreateDiscountedItem < Benefit
       def perform(order)
         line_item = find_item(order) || build_item(order)
         set_quantity(line_item, determine_item_quantity(order))
-        line_item.current_discounts << discount_line_item(line_item)
+        discount_line_item(line_item)
       end
 
       def remove_from(order)
@@ -25,13 +25,21 @@ def level
       private
 
       def discount_line_item(line_item, ...)
-        amount = compute_amount(line_item, ...)
-        return if amount.zero?
+        adjustment = find_adjustment(line_item) || build_adjustment(line_item)
+        adjustment.amount = compute_amount(line_item, ...)
+        adjustment.label = adjustment_label(line_item)
+        adjustment
+      end
+
+      def find_adjustment(line_item)
+        line_item.adjustments.detect do |adjustment|
+          adjustment.source == self
+        end
+      end
 
-        ItemDiscount.new(
-          item: line_item,
-          label: adjustment_label(line_item),
-          amount: amount,
+      def build_adjustment(line_item)
+        line_item.adjustments.build(
+          order: line_item.order,
           source: self
         )
       end

promotions/app/models/solidus_promotions/order_adjuster.rb

@@ -14,25 +14,13 @@ def initialize(order, dry_run_promotion: nil)
     end
 
     def call
-      order.reset_current_discounts
-
       return order unless SolidusPromotions::Promotion.order_activatable?(order)
 
-      discounted_order = DiscountOrder.new(order, promotions, dry_run: dry_run).call
-
-      PersistDiscountedOrder.new(discounted_order).call unless dry_run
+      SetDiscountsToZero.call(order)
 
-      order.reset_current_discounts
+      DiscountOrder.new(order, promotions, dry_run: dry_run).call
 
-      unless dry_run
-        # Since automations might have added a line item, we need to recalculate
-        # item total and item count here.
-        line_items = order.line_items.reject(&:marked_for_destruction?)
-        order.item_total = line_items.sum(&:amount)
-        order.item_count = line_items.sum(&:quantity)
-        order.promo_total = (line_items + order.shipments).sum(&:promo_total)
-      end
-      order
+      RecalculatePromoTotals.call(order)
     end
   end
 end

promotions/app/models/solidus_promotions/order_adjuster/discount_order.rb

@@ -15,14 +15,13 @@ def call
         return order if order.shipped?
 
         SolidusPromotions::Promotion.ordered_lanes.each do |lane|
-          lane_promotions = promotions.select { |promotion| promotion.lane == lane }
-          lane_benefits = eligible_benefits_for_promotable(lane_promotions.flat_map(&:benefits), order)
-          perform_order_benefits(lane_benefits, lane) unless dry_run
-          line_item_discounts = adjust_line_items(lane_benefits)
-          shipment_discounts = adjust_shipments(lane_benefits)
-          shipping_rate_discounts = adjust_shipping_rates(lane_benefits)
-          (line_item_discounts + shipment_discounts + shipping_rate_discounts).each do |item, chosen_discounts|
-            item.current_discounts.concat(chosen_discounts)
+          SolidusPromotions::PromotionLane.set(current_lane: lane) do
+            lane_promotions = promotions.select { |promotion| promotion.lane == lane }
+            lane_benefits = eligible_benefits_for_promotable(lane_promotions.flat_map(&:benefits), order)
+            perform_order_benefits(lane_benefits, lane) unless dry_run
+            adjust_line_items(lane_benefits)
+            adjust_shipments(lane_benefits)
+            adjust_shipping_rates(lane_benefits)
           end
         end
 
@@ -49,26 +48,25 @@ def adjust_line_items(benefits)
           next unless line_item.variant.product.promotionable?
 
           discounts = generate_discounts(benefits, line_item)
-          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
-          [line_item, chosen_item_discounts]
+          chosen_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          (line_item.current_lane_discounts - chosen_discounts).each(&:mark_for_destruction)
         end
       end
 
       def adjust_shipments(benefits)
         order.shipments.map do |shipment|
           discounts = generate_discounts(benefits, shipment)
-          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
-          [shipment, chosen_item_discounts]
+          chosen_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          (shipment.current_lane_discounts - chosen_discounts).each(&:mark_for_destruction)
         end
       end
 
       def adjust_shipping_rates(benefits)
         order.shipments.flat_map(&:shipping_rates).filter_map do |rate|
           next unless rate.cost
-
           discounts = generate_discounts(benefits, rate)
-          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
-          [rate, chosen_item_discounts]
+          chosen_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          (rate.current_lane_discounts - chosen_discounts).each(&:mark_for_destruction)
         end
       end