solidus_promotions 4.6.2 → 4.7.0

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

@@ -14,15 +14,14 @@ module SolidusPromotions
       def call
         return order if order.shipped?
 
-        SolidusPromotions::Promotion.ordered_lanes.each_key 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::Promotion.ordered_lanes.each do |lane|
+          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
 
@@ -32,45 +31,42 @@ module SolidusPromotions
       private
 
       def perform_order_benefits(lane_benefits, lane)
-        lane_benefits.select { |benefit| benefit.level == :order }.each do |benefit|
-          benefit.perform(order)
+        lane_benefits.filter_map do |benefit|
+          benefit.respond_to?(:perform) && benefit.perform(order)
         end
 
-        automated_line_items = order.line_items.select(&:managed_by_order_benefit)
-        return if automated_line_items.empty?
-
-        ineligible_line_items = automated_line_items.select do |line_item|
-          line_item.managed_by_order_benefit.promotion.lane == lane && !line_item.managed_by_order_benefit.in?(lane_benefits)
-        end
-
-        ineligible_line_items.each do |line_item|
-          line_item.managed_by_order_benefit.remove_from(order)
+        order.line_items.filter_map do |line_item|
+          line_item.managed_by_order_benefit &&
+            line_item.managed_by_order_benefit.promotion.lane == lane &&
+            !line_item.managed_by_order_benefit.in?(lane_benefits) &&
+            line_item.managed_by_order_benefit.remove_from(order)
         end
       end
 
       def adjust_line_items(benefits)
-        order.discountable_line_items.select do |line_item|
-          line_item.variant.product.promotionable?
-        end.map do |line_item|
+        order.discountable_line_items.filter_map do |line_item|
+          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).select(&:cost).map do |rate|
+        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
 
@@ -82,11 +78,9 @@ module SolidusPromotions
 
       def generate_discounts(possible_benefits, item)
         eligible_benefits = eligible_benefits_for_promotable(possible_benefits, item)
-        eligible_benefits.select do |benefit|
-          benefit.can_discount?(item)
-        end.map do |benefit|
-          benefit.discount(item)
-        end.compact
+        eligible_benefits.filter_map do |benefit|
+          benefit.can_discount?(item) && benefit.discount(item)
+        end
       end
     end
   end

data/app/models/solidus_promotions/order_adjuster/recalculate_promo_totals.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class OrderAdjuster
+    module RecalculatePromoTotals
+      extend self
+
+      def call(order)
+        order.line_items.each do |line_item|
+          line_item.adjustments.select { _1.amount.zero? }.each(&:mark_for_destruction)
+
+          line_item.promo_total = calculate_promo_total_for_adjustable(line_item)
+        end
+
+        order.shipments.each do |shipment|
+          shipment.adjustments.select { _1.amount.zero? }.each(&:mark_for_destruction)
+          shipment.shipping_rates.each do |shipping_rate|
+            shipping_rate.discounts.select { _1.amount.zero? }.each(&:mark_for_destruction)
+          end
+
+          shipment.promo_total = calculate_promo_total_for_adjustable(shipment)
+        end
+
+        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.reject(&:marked_for_destruction?)).sum(&:promo_total)
+
+        order.adjustment_total = order.promo_total
+        order
+      end
+
+      private
+
+      def calculate_promo_total_for_adjustable(adjustable)
+        adjustable
+          .adjustments
+          .select(&:promotion?)
+          .reject(&:marked_for_destruction?)
+          .sum(&:amount)
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/order_adjuster/set_discounts_to_zero.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class OrderAdjuster
+    module SetDiscountsToZero
+      extend self
+
+      def call(order)
+        order.line_items.each do |line_item|
+          reset_item_adjustments(line_item)
+        end
+
+        order.shipments.each do |shipment|
+          reset_item_adjustments(shipment)
+          shipment.shipping_rates.each do |shipping_rate|
+            reset_shipping_rate_discounts(shipping_rate)
+          end
+        end
+        order
+      end
+
+      private
+
+      def reset_item_adjustments(item)
+        item.adjustments.select(&:promotion?).each { |adjustment| adjustment.amount = 0 }
+      end
+
+      def reset_shipping_rate_discounts(rate)
+        rate.discounts.each { |discount| discount.amount = 0 }
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/order_adjuster.rb

@@ -13,24 +13,14 @@ module SolidusPromotions
       ).call
     end
 
-    def call
-      order.reset_current_discounts
-
+    def call(persist: true) # rubocop:disable Lint/UnusedMethodArgument
       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.
-        order.item_total = order.line_items.sum(&:amount)
-        order.item_count = order.line_items.sum(&:quantity)
-        order.promo_total = (order.line_items + order.shipments).sum(&:promo_total)
-      end
-      order
+      RecalculatePromoTotals.call(order)
     end
   end
 end

data/app/models/solidus_promotions/order_promotion.rb

@@ -11,6 +11,7 @@ module SolidusPromotions
     belongs_to :promotion_code, class_name: "SolidusPromotions::PromotionCode", optional: true
 
     validates :promotion_code, presence: true, if: :require_promotion_code?
+    validates :promotion_id, uniqueness: {scope: :order_id}
 
     self.allowed_ransackable_associations = %w[promotion_code]
 

data/app/models/solidus_promotions/product_advertiser.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class ProductAdvertiser
+    attr_reader :order, :product, :promotions, :quantity
+
+    def initialize(product:, order:, quantity: 1)
+      @product = product
+      @order = order
+      @quantity = quantity
+      @promotions = SolidusPromotions::LoadPromotions.new(order:).call
+    end
+
+    def call
+      return unless product.promotionable?
+
+      SolidusPromotions::Promotion.ordered_lanes.each do |lane|
+        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)
+
+          if product.has_variants?
+            product.variants.each { |variant| discount_variant(variant, lane_benefits) }
+          else
+            discount_variant(product.master, lane_benefits)
+          end
+        end
+      end
+    end
+
+    private
+
+    def discount_variant(variant, benefits)
+      variant.prices.each do |price|
+        next if price.discarded?
+        discounts = generate_discounts(benefits, price)
+        chosen_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+        price.discounts.concat(chosen_discounts)
+      end
+    end
+
+    def eligible_benefits_for_promotable(possible_benefits, promotable)
+      possible_benefits.select do |candidate|
+        candidate.eligible_by_applicable_conditions?(promotable)
+      end
+    end
+
+    def generate_discounts(possible_benefits, item)
+      eligible_benefits = eligible_benefits_for_promotable(possible_benefits, item)
+      eligible_benefits.filter_map do |benefit|
+        next unless benefit.can_discount?(item)
+
+        benefit.discount(item, order:, quantity:)
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/promotion.rb

@@ -19,10 +19,10 @@ module SolidusPromotions
     has_many :order_promotions, class_name: "SolidusPromotions::OrderPromotion", dependent: :destroy
 
     validates :name, :customer_label, presence: true
-    validates :path, uniqueness: { allow_blank: true, case_sensitive: true }
-    validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
-    validates :per_code_usage_limit, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
-    validates :description, length: { maximum: 255 }
+    validates :path, uniqueness: {allow_blank: true, case_sensitive: true}
+    validates :usage_limit, numericality: {greater_than: 0, allow_nil: true}
+    validates :per_code_usage_limit, numericality: {greater_than_or_equal_to: 0, allow_nil: true}
+    validates :description, length: {maximum: 255}
     validate :apply_automatically_disallowed_with_paths
     validate :apply_automatically_disallowed_with_promotion_codes
 
@@ -46,7 +46,9 @@ module SolidusPromotions
 
     def self.with_coupon_code(val)
       joins(:codes).where(
-        SolidusPromotions::PromotionCode.arel_table[:value].eq(val.downcase)
+        SolidusPromotions::PromotionCode.arel_table[:value].eq(
+          SolidusPromotions.config.coupon_code_normalizer_class.call(val)
+        )
       ).first
     end
 
@@ -55,13 +57,13 @@ module SolidusPromotions
     end
 
     def self.lane_options
-      ordered_lanes.map do |lane_name, _index|
-        [human_enum_name(:lane, lane_name), lane_name]
+      ordered_lanes.map do |lane|
+        [human_enum_name(:lane, lane), lane]
       end
     end
 
     def self.ordered_lanes
-      lanes.sort_by(&:last).to_h
+      lanes.keys.sort_by { |lane| lanes[lane] }
     end
 
     def self.order_activatable?(order)
@@ -96,7 +98,7 @@ module SolidusPromotions
       discounted_orders
         .complete
         .where.not(id: [excluded_orders.map(&:id)])
-        .where.not(spree_orders: { state: :canceled })
+        .where.not(spree_orders: {state: :canceled})
         .count
     end
 
@@ -105,7 +107,7 @@ module SolidusPromotions
         .complete
         .where.not(id: excluded_orders.map(&:id))
         .where(user: user)
-        .where.not(spree_orders: { state: :canceled })
+        .where.not(spree_orders: {state: :canceled})
         .exists?
     end
 

data/app/models/solidus_promotions/promotion_code/batch_builder.rb

@@ -22,7 +22,7 @@ module SolidusPromotions
       def build_promotion_codes
         generate_random_codes
         promotion_code_batch.update!(state: "completed")
-      rescue StandardError => e
+      rescue => e
         promotion_code_batch.update!(
           error: e.inspect,
           state: "failed"

data/app/models/solidus_promotions/promotion_code.rb

@@ -9,7 +9,7 @@ module SolidusPromotions
 
     before_validation :normalize_code
 
-    validates :value, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
+    validates :value, presence: true, uniqueness: {allow_blank: true, case_sensitive: true}
     validate :promotion_not_apply_automatically, on: :create
 
     self.allowed_ransackable_attributes = ["value"]
@@ -32,9 +32,9 @@ module SolidusPromotions
       promotion
         .discounted_orders
         .complete
-        .where.not(spree_orders: { state: :canceled })
+        .where.not(spree_orders: {state: :canceled})
         .joins(:solidus_order_promotions)
-        .where(SolidusPromotions::OrderPromotion.table_name => { promotion_code_id: id })
+        .where(SolidusPromotions::OrderPromotion.table_name => {promotion_code_id: id})
         .where.not(id: excluded_orders.map(&:id))
         .count
     end
@@ -50,7 +50,7 @@ module SolidusPromotions
     private
 
     def normalize_code
-      self.value = value.downcase.strip
+      self.value = SolidusPromotions.config.coupon_code_normalizer_class.call(value)
     end
   end
 end

data/app/models/solidus_promotions/promotion_code_batch.rb

@@ -8,7 +8,7 @@ module SolidusPromotions
     belongs_to :promotion
     has_many :promotion_codes, dependent: :destroy
 
-    validates :number_of_codes, numericality: { greater_than: 0 }
+    validates :number_of_codes, numericality: {greater_than: 0}
     validates :base_code, :number_of_codes, presence: true
 
     def finished?

data/app/models/solidus_promotions/promotion_handler/coupon.rb

@@ -9,7 +9,7 @@ module SolidusPromotions
       def initialize(order)
         @order = order
         @errors = []
-        @coupon_code = order&.coupon_code&.downcase
+        @coupon_code = SolidusPromotions.config.coupon_code_normalizer_class.call(order&.coupon_code)
       end
 
       def apply

data/app/models/solidus_promotions/promotion_handler/page.rb

@@ -7,7 +7,7 @@ module SolidusPromotions
 
       def initialize(order, path)
         @order = order
-        @path = path.delete_prefix('/')
+        @path = path.delete_prefix("/")
       end
 
       def activate

data/app/models/solidus_promotions/promotion_lane.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  # PromotionLane is a thread-safe current attributes class that manages the current promotion lane context.
+  #
+  # This class extends ActiveSupport::CurrentAttributes to provide thread-local storage for the current
+  # promotion lane. It allows setting and retrieving the current lane, as well as getting all lanes
+  # that come before the current one.
+  #
+  # @example Setting and retrieving the current lane
+  #   PromotionLane.current_lane = :pre
+  #   PromotionLane.current_lane # => "pre"
+  #
+  # @example Getting lanes before the current one
+  #   PromotionLane.current_lane = :post
+  #   PromotionLane.previous_lanes # => ["pre"]
+  #
+  # @see ActiveSupport::CurrentAttributes
+  class PromotionLane < ActiveSupport::CurrentAttributes
+    attribute :current_lane
+
+    def current_lane=(arg)
+      if arg.present?
+        super(arg.to_s)
+      else
+        super
+      end
+    end
+
+    # Retrieves the lanes that occur before the current lane in the promotion flow.
+    #
+    # Delegates to `before(current_lane)` to compute the preceding lanes.
+    #
+    # Special considerations:
+    # - If `current_lane` is `nil`, all lanes are returned.
+    #
+    # @return [Array<String>] the set of lanes preceding the current lane; all lanes if no current lane is set
+    def previous_lanes
+      before(current_lane)
+    end
+
+    private
+
+    def before(lane)
+      Promotion.ordered_lanes.split(lane).first
+    end
+  end
+end

data/app/models/solidus_promotions/shipping_rate_discount.rb

@@ -5,7 +5,10 @@ module SolidusPromotions
     belongs_to :shipping_rate, inverse_of: :discounts, class_name: "Spree::ShippingRate"
     belongs_to :benefit, inverse_of: :shipping_rate_discounts
 
+    alias_method :source, :benefit
+
     extend Spree::DisplayMoney
+
     money_methods :amount
   end
 end

data/app/patches/models/solidus_promotions/line_item_patch.rb

@@ -22,6 +22,8 @@ module SolidusPromotions
     end
 
     Spree::LineItem.prepend self
+    Spree::LineItem.prepend SolidusPromotions::AdjustmentDiscounts
+    Spree::LineItem.prepend SolidusPromotions::DiscountedAmount
     Spree::LineItem.prepend SolidusPromotions::DiscountableAmount
   end
 end

data/app/patches/models/solidus_promotions/order_patch.rb

@@ -36,6 +36,14 @@ module SolidusPromotions
       !line_item.managed_by_order_benefit
     end
 
+    def coupon_code=(code)
+      @coupon_code = begin
+        SolidusPromotions.config.coupon_code_normalizer_class.call(code)
+      rescue
+        nil
+      end
+    end
+
     Spree::Order.singleton_class.prepend self::ClassMethods
     Spree::Order.prepend self
   end

data/app/patches/models/solidus_promotions/order_recalculator_patch.rb

@@ -10,6 +10,8 @@ module SolidusPromotions
       end
       super
     end
-    Spree::Config.order_recalculator_class.prepend self
+
+    Spree::OrderUpdater.prepend self
+    Spree::InMemoryOrderUpdater.prepend self
   end
 end

data/app/patches/models/solidus_promotions/price_patch.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module PricePatch
+    def self.prepended(base)
+      base.money_methods :discounted_amount
+    end
+
+    def discounts
+      @discounts ||= []
+    end
+
+    attr_writer :discounts
+
+    private
+
+    # Returns discounts from specified promotion lanes.
+    #
+    # @param lanes [Array] An array of lanes to filter discounts by.
+    # @return [Array<SolidusPromotions::ShippingRateDiscount] An array of discounts from the
+    #   specified lans that are not marked for destruction.
+    def discounts_by_lanes(lanes)
+      discounts.select do |discount|
+        discount.source.promotion.lane.in?(lanes)
+      end
+    end
+
+    Spree::Price.prepend SolidusPromotions::DiscountedAmount
+    Spree::Price.prepend self
+  end
+end

data/app/patches/models/solidus_promotions/shipment_patch.rb

@@ -10,5 +10,7 @@ module SolidusPromotions
     end
 
     Spree::Shipment.prepend self
+    Spree::Shipment.prepend SolidusPromotions::AdjustmentDiscounts
+    Spree::Shipment.prepend SolidusPromotions::DiscountedAmount
   end
 end

data/app/patches/models/solidus_promotions/shipping_rate_patch.rb

@@ -23,7 +23,22 @@ module SolidusPromotions
       discounts.sum(&:amount)
     end
 
+    private
+
+    # Returns discounts from specified promotion lanes.
+    #
+    # @param lanes [Array] An array of lanes to filter discounts by.
+    # @return [Array<SolidusPromotions::ShippingRateDiscount] An array of discounts from the
+    #   specified lans that are not marked for destruction.
+    def discounts_by_lanes(lanes)
+      discounts.select do |discount|
+        !discount.marked_for_destruction? &&
+          discount.benefit.promotion.lane.in?(lanes)
+      end
+    end
+
     Spree::ShippingRate.prepend SolidusPromotions::DiscountableAmount
+    Spree::ShippingRate.prepend SolidusPromotions::DiscountedAmount
     Spree::ShippingRate.prepend self
   end
 end