solidus_promotions 4.6.1 → 4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 358bcbcde0ecbd8969cf3a23f9f68e1188b6b54b4a4b9a3c58253def1d3ab29e
-  data.tar.gz: '01182178d5ec81589d8079c88db347de3dd4e94c53ccfcaf76683de82f0ed8d7'
+  metadata.gz: aaae8dc702bc52d537b6e0e3ab7a77ec52091890f443a6a30a63c3de58c6a097
+  data.tar.gz: ea14d817d57406914450fe4690b9dbf4db628f11cb456c15b7a92b53fdf293a7
 SHA512:
-  metadata.gz: 8d2ef2442707d6193bf3bfc10a58203960a4950c3dc2e02a6006bbbe0ca8bf16b19885023f33a0fbd8caadbf30782e1a5c52d1511fcbda88c72867ebedf5f4a8
-  data.tar.gz: 240167352cd02bd3b82ce6e24608b1d252cf223d08f92827c0ca7942e622fca392a50bc78afc8f54e8269a39d14f56d350d347ce50d7816096ee14b407ce8e4a
+  metadata.gz: 60687b2516232af51dc68e97acbb2ef345eab68265917435991ce48bca89c5cc015c12e96fd2268e65c06ed3b3d38b8b1a2c4a49760fd5d09823886d9866d978
+  data.tar.gz: 017a4995a3feafd499cff0ccadd46665c003fdc45396f385e639222da15684fb177ee2f0a7bddedb6663a42a392c5301a386f1667281e21e85c45521e7e27070

data/MIGRATING.md

@@ -96,10 +96,14 @@ If you have custom promotion rules or actions, you need to create new conditions
 
 In our experience, using the three actions can do almost all the things necessary, since they are customizable using calculators.
 
-Rules share a lot of the previous API. If you make use of `#actionable?`, you might want to migrate your rule to be a line-item level rule:
+Rules share a lot of the previous API. If you make use of `#actionable?`, you might want to migrate your rule to be a combined order and line-item level rule:
 
 ```rb
 class MyRule < Spree::PromotionRule
+  def eligible?(order)
+    order.total > 100
+  end
+
   def actionable?(promotable)
     promotable.quantity > 3
   end
@@ -110,10 +114,12 @@ would become:
 
 ```rb
 class MyCondition < SolidusPromotions::Condition
-  include LineItemLevelCondition
+  def order_eligible?(order, _options = {})
+    order.total > 100
+  end
 
-  def eligible?(promotable)
-    promotable.quantity > 3
+  def line_item_eligible?(line_item, _options = {})
+    line_item.quantity > 3
   end
 end
 ```

data/README.md

@@ -70,6 +70,13 @@ SolidusPromotions.configure do |config|
 end
 ```
 
+### Coupon Code Normalization
+
+Solidus Promotions provides a configurable coupon code normalizer that controls how coupon codes are processed before saving and lookup. By default, codes are case-insensitive (e.g., "SAVE20" and "save20" are treated as the same). 
+You can customize this behavior to support case-sensitive codes, remove special characters, apply formatting rules, or implement other normalization strategies based on your business requirements.
+
+See the `coupon_code_normalizer_class` configuration option for implementation details.
+
 ## Installation
 
 Add solidus_promotions to your Gemfile:

data/app/javascript/backend/solidus_promotions/controllers/product_option_values_controller.js

@@ -6,8 +6,6 @@ export default class extends Controller {
   connect() {
     this.wrapperClass =
       this.data.get("wrapperClass") || "promo-condition-option-value";
-
-    this.element.querySelectorAll("." + this.wrapperClass).forEach((element) => this.buildSelects(element))
   }
 
   add_row(event) {
@@ -15,7 +13,6 @@ export default class extends Controller {
 
     var content = this.templateTarget.innerHTML;
     this.linksTarget.insertAdjacentHTML("beforebegin", content);
-    this.buildSelects(this.linksTarget.previousElementSibling)
   }
 
   propagate_product_id_to_value_input(event) {
@@ -24,7 +21,9 @@ export default class extends Controller {
     // we first need to greedily match all other square brackets
     const regEx = /(\[.*\])\[.*?\]$/;
     let wrapper = event.target.closest("." + this.wrapperClass);
-    let optionValuesInput = wrapper.querySelector(".option-values-select[type='hidden']");
+    let optionValuesInput = wrapper.querySelector("[is=option-value-picker]");
+    optionValuesInput.dataset.productId = event.target.value;
+    optionValuesInput.value = "";
     optionValuesInput.name = optionValuesInput.name.replace(
       regEx,
       `$1[${event.target.value}]`
@@ -37,26 +36,4 @@ export default class extends Controller {
     let wrapper = event.target.closest("." + this.wrapperClass);
     wrapper.remove();
   }
-
-  // helper functions
-
-  buildSelects(wrapper) {
-    let productSelect = wrapper.querySelector(".product-select")
-    let optionValueSelect = wrapper.querySelector(".option-values-select[type='hidden']")
-    this.buildProductSelect(productSelect)
-    $(optionValueSelect).optionValueAutocomplete({ productSelect });
-  }
-
-  buildProductSelect(productSelect) {
-    var jQueryProductSelect = $(productSelect)
-    jQueryProductSelect.productAutocomplete({
-      multiple: false,
-    })
-    // capture the jQuery "change" event and re-emit it as DOM event "select2Change"
-    // so that Stimulus can capture it
-    jQueryProductSelect.on('change', function () {
-      let event = new Event('select2Change', { bubbles: true }) // fire a native event
-      productSelect.dispatchEvent(event);
-    });
-  }
 }

data/app/javascript/backend/solidus_promotions/web_components/option_value_picker.js

@@ -1,11 +1,9 @@
 $.fn.optionValueAutocomplete = function (options) {
-  'use strict';
+  "use strict";
 
   // Default options
-  options = options || {}
-  var multiple = typeof(options['multiple']) !== 'undefined' ? options['multiple'] : true;
-  var productSelect = options['productSelect'];
-
+  options = options || {};
+  var multiple = typeof options["multiple"] !== "undefined" ? options["multiple"] : true;
   function formatOptionValue(option_value) {
     return Select2.util.escapeMarkup(option_value.name);
   }
@@ -14,39 +12,58 @@ $.fn.optionValueAutocomplete = function (options) {
     minimumInputLength: 3,
     multiple: multiple,
     initSelection: function (element, callback) {
-      $.get(Spree.pathFor('api/option_values'), {
-        ids: element.val().split(','),
-        token: Spree.api_key
-      }, function (data) {
-        callback(multiple ? data : data[0]);
-      });
+      $.get(
+        Spree.pathFor("api/option_values"),
+        {
+          ids: element.val().split(","),
+          token: Spree.api_key,
+        },
+        function (data) {
+          callback(multiple ? data : data[0]);
+        }
+      );
     },
     ajax: {
-      url: Spree.pathFor('api/option_values'),
-      datatype: 'json',
+      url: Spree.pathFor("api/option_values"),
+      datatype: "json",
       data: function (term, page) {
-        var productId = typeof(productSelect) !== 'undefined' ? $(productSelect).select2('val') : null;
+        var productId = this[0].dataset.productId;
         return {
           q: {
             name_cont: term,
-            variants_product_id_eq: productId
+            variants_product_id_eq: productId,
           },
-          token: Spree.api_key
+          token: Spree.api_key,
         };
       },
       results: function (data, page) {
         return { results: data };
-      }
+      },
     },
     formatResult: formatOptionValue,
-    formatSelection: formatOptionValue
+    formatSelection: formatOptionValue,
   });
 };
 
 class OptionValuePicker extends HTMLInputElement {
   connectedCallback() {
     $(this).optionValueAutocomplete();
+
+    this.observer = new MutationObserver((muts) => {
+      for (const m of muts) {
+        if (m.attributeName.startsWith("data-product-id")) {
+          this.restart();
+        }
+      }
+    });
+
+    this.observer.observe(this, { attributes: true });
+  }
+
+  restart() {
+    $(this).select2("destroy");
+    $(this).optionValueAutocomplete();
   }
 }
 
-customElements.define('option-value-picker', OptionValuePicker, { extends: 'input' });
+customElements.define("option-value-picker", OptionValuePicker, { extends: "input" });

data/app/javascript/backend/solidus_promotions/web_components/product_picker.js

@@ -1,6 +1,11 @@
 class ProductPicker extends HTMLInputElement {
   connectedCallback() {
-    $(this).productAutocomplete();
+    const multiple = this.dataset.multiple !== "false";
+    $(this).productAutocomplete({ multiple });
+    $(this).on("change", (_) => {
+      let event = new Event('select2Change', { bubbles: true }) // fire a native event
+      this.dispatchEvent(event)
+    })
   }
 }
 

data/app/jobs/solidus_promotions/promotion_code_batch_job.rb

@@ -14,7 +14,7 @@ module SolidusPromotions
           .promotion_code_batch_finished(promotion_code_batch)
           .deliver_now
       end
-    rescue StandardError => e
+    rescue => e
       if promotion_code_batch.email?
         SolidusPromotions.config.promotion_code_batch_mailer_class
           .promotion_code_batch_errored(promotion_code_batch)

data/app/models/concerns/solidus_promotions/adjustment_discounts.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module AdjustmentDiscounts
+    private
+
+    # Returns adjustments from specified promotion lanes.
+    #
+    # @param lanes [Array<String>] the promotion lanes to filter by
+    # @return [Array<Spree::Adjustment>] promotions adjustments from the
+    #   specified lanes that are not marked for destruction
+    def discounts_by_lanes(lanes)
+      adjustments.select do |adjustment|
+        !adjustment.marked_for_destruction? &&
+          adjustment.source_type == "SolidusPromotions::Benefit" &&
+          adjustment.source.promotion.lane.in?(lanes)
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_promotions/benefits/line_item_benefit.rb

@@ -3,6 +3,10 @@
 module SolidusPromotions
   module Benefits
     module LineItemBenefit
+      def self.included(_base)
+        Spree.deprecator.warn("Including #{name} is deprecated.")
+      end
+
       def can_discount?(object)
         object.is_a? Spree::LineItem
       end
@@ -10,6 +14,7 @@ module SolidusPromotions
       def level
         :line_item
       end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

data/app/models/concerns/solidus_promotions/benefits/order_benefit.rb

@@ -3,6 +3,10 @@
 module SolidusPromotions
   module Benefits
     module OrderBenefit
+      def self.included(_base)
+        Spree.deprecator.warn("Including #{name} is deprecated.")
+      end
+
       def can_discount?(_)
         false
       end
@@ -10,6 +14,7 @@ module SolidusPromotions
       def level
         :order
       end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

data/app/models/concerns/solidus_promotions/benefits/shipment_benefit.rb

@@ -3,6 +3,10 @@
 module SolidusPromotions
   module Benefits
     module ShipmentBenefit
+      def self.included(_base)
+        Spree.deprecator.warn("Including #{name} is deprecated.")
+      end
+
       def can_discount?(object)
         object.is_a?(Spree::Shipment) || object.is_a?(Spree::ShippingRate)
       end
@@ -10,6 +14,7 @@ module SolidusPromotions
       def level
         :shipment
       end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

data/app/models/concerns/solidus_promotions/calculators/promotion_calculator.rb

@@ -6,6 +6,13 @@ module SolidusPromotions
       def description
         self.class.human_attribute_name(:description)
       end
+
+      private
+
+      def round_to_currency(number, currency)
+        currency_exponent = ::Money::Currency.find(currency).exponent
+        number.round(currency_exponent)
+      end
     end
   end
 end

data/app/models/concerns/solidus_promotions/conditions/line_item_applicable_order_level_condition.rb

@@ -8,16 +8,28 @@ module SolidusPromotions
       end
 
       def applicable?(promotable)
-        promotable.is_a?(Spree::Order) || preferred_line_item_applicable && promotable.is_a?(Spree::LineItem)
-      end
-
-      def eligible?(promotable)
-        send(:"#{promotable.class.name.demodulize.underscore}_eligible?", promotable)
+        if preferred_line_item_applicable == false
+          Spree.deprecator.warn <<~MSG
+            Setting `#{self.class.name}#preferred_line_item_applicable` to false is deprecated.
+            Please use a suitable condition that only checks the order instead, such as `OrderProduct`,
+            `OrderTaxon`, or `OrderOptionValue`. If you have included the `LineItemApplicableOrderLevelCondition` module
+            yourself, create a new condition that only checks orders:
+            ```
+            class MyCondition < SolidusPromotions::Condition
+              def order_eligible?(order, _options = {})
+                # your logic here
+              end
+            end
+            ```
+          MSG
+        end
+        promotable.is_a?(Spree::LineItem) ? preferred_line_item_applicable && super : super
       end
 
       def level
         :order
       end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

data/app/models/concerns/solidus_promotions/conditions/line_item_level_condition.rb

@@ -3,13 +3,26 @@
 module SolidusPromotions
   module Conditions
     module LineItemLevelCondition
-      def applicable?(promotable)
-        promotable.is_a?(Spree::LineItem)
+      def self.included(base)
+        def base.method_added(method)
+          if method == :eligible?
+            Spree.deprecator.warn <<~MSG
+              Defining `eligible?` on a promotion along with including the `LineItemLevelCondition` module is deprecated.
+              Rename `eligible?` to `line_item_eligible?` and stop including the `LineItemLevelCondition` module.
+            MSG
+            define_method(:applicable?) do |promotable|
+              promotable.is_a?(Spree::LineItem)
+            end
+          end
+
+          super
+        end
       end
 
       def level
         :line_item
       end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

data/app/models/concerns/solidus_promotions/conditions/option_value_condition.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    module OptionValueCondition
+      def self.included(base)
+        base.preference :eligible_values, :hash
+        base.remove_method :preferred_eligible_values
+      end
+
+      def preferred_eligible_values
+        values = preferences[:eligible_values] || {}
+        values.keys.map(&:to_i).zip(
+          values.values.map do |value|
+            (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
+          end
+        ).to_h
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_promotions/conditions/order_level_condition.rb

@@ -3,13 +3,26 @@
 module SolidusPromotions
   module Conditions
     module OrderLevelCondition
-      def applicable?(promotable)
-        promotable.is_a?(Spree::Order)
+      def self.included(base)
+        def base.method_added(method)
+          if method == :eligible?
+            Spree.deprecator.warn <<~MSG
+              Defining `eligible?` on a promotion along with including the `OrderLevelCondition` module is deprecated.
+              Rename `eligible?` to `order_eligible?` and stop including the `OrderLevelCondition` module.
+            MSG
+            define_method(:applicable?) do |promotable|
+              promotable.is_a?(Spree::Order)
+            end
+          end
+
+          super
+        end
       end
 
       def level
         :order
       end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

data/app/models/concerns/solidus_promotions/conditions/product_condition.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    module ProductCondition
+      def self.included(base)
+        base.has_many :condition_products,
+          dependent: :destroy,
+          foreign_key: :condition_id,
+          class_name: "SolidusPromotions::ConditionProduct",
+          inverse_of: :condition
+        base.has_many :products, class_name: "Spree::Product", through: :condition_products
+      end
+
+      def preload_relations
+        [:products]
+      end
+
+      def product_ids_string
+        product_ids.join(",")
+      end
+
+      def product_ids_string=(product_ids)
+        self.product_ids = product_ids.to_s.split(",").map(&:strip)
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_promotions/conditions/shipment_level_condition.rb

@@ -3,13 +3,26 @@
 module SolidusPromotions
   module Conditions
     module ShipmentLevelCondition
-      def applicable?(promotable)
-        promotable.is_a?(Spree::Shipment)
+      def self.included(base)
+        def base.method_added(method)
+          if method == :eligible?
+            Spree.deprecator.warn <<~MSG
+              Defining `eligible?` on a promotion along with including the `ShipmentLevelCondition` module is deprecated.
+              Rename `eligible?` to `shipment_eligible?` and stop including the `ShipmentLevelCondition` module.
+            MSG
+            define_method(:applicable?) do |promotable|
+              promotable.is_a?(Spree::Shipment)
+            end
+          end
+
+          super
+        end
       end
 
       def level
         :shipment
       end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

data/app/models/concerns/solidus_promotions/conditions/taxon_condition.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    module TaxonCondition
+      def self.included(base)
+        base.has_many :condition_taxons,
+          class_name: "SolidusPromotions::ConditionTaxon",
+          foreign_key: :condition_id,
+          dependent: :destroy,
+          inverse_of: :condition
+        base.has_many :taxons, through: :condition_taxons, class_name: "Spree::Taxon"
+      end
+
+      def preload_relations
+        [:taxons]
+      end
+
+      def taxon_ids_string
+        taxon_ids.join(",")
+      end
+
+      def taxon_ids_string=(taxon_ids)
+        taxon_ids = taxon_ids.to_s.split(",").map(&:strip)
+        self.taxons = Spree::Taxon.find(taxon_ids)
+      end
+
+      def taxons_ids_with_children=(args)
+        @taxon_ids_with_children = args
+      end
+
+      private
+
+      # Returns the cached list of taxon subtree id collections for the selected taxons.
+      #
+      # Executes a single SQL query using the nested set (lft/rgt) boundaries to
+      # fetch each root taxon (one of this condition's taxons) together with all
+      # of its descendants. The result is memoized for the lifetime of the
+      # condition instance.
+      #
+      # Each inner array contains the IDs of a root taxon and all of its
+      # descendants (including the root itself). The outer array is ordered by
+      # the root taxon id.
+      #
+      # @return [Array<Array<Integer>>] array of arrays of taxon ids, one per root taxon
+      # @example
+      #   # For condition with taxons [10, 42]
+      #   condition.condition_taxon_ids_with_children
+      #   # => [[10, 11, 12], [42, 43]]
+      def taxon_ids_with_children
+        @taxon_ids_with_children ||= load_taxon_ids_with_children
+      end
+
+      def load_taxon_ids_with_children
+        aggregation_function = if ActiveRecord::Base.connection.adapter_name.downcase.match?(/postgres/)
+          "string_agg(child.id::text, ',')"
+        else
+          "group_concat(child.id, ',')"
+        end
+
+        sql = <<~SQL
+          SELECT
+            parent.id AS root_id,
+            #{aggregation_function} AS descendant_ids
+          FROM spree_taxons AS parent
+          JOIN spree_taxons AS child
+            ON child.lft BETWEEN parent.lft AND parent.rgt
+          WHERE parent.id IN (#{taxon_ids.join(",")})
+          GROUP BY parent.id
+          ORDER BY parent.id
+        SQL
+        rows = ActiveRecord::Base.connection.exec_query(sql)
+        rows.map { |r| r["descendant_ids"].split(",").map(&:to_i) }
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_promotions/coupon_code_normalizer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  # Normalizes coupon codes before saving or looking up promotions.
+  #
+  # By default, this class strips whitespace and downcases the code
+  # to ensure case-insensitive behavior. You can override this class
+  # or provide a custom normalizer class to change behavior (e.g.,
+  # case-sensitive codes) via:
+  #
+  #   SolidusPromotions.configure do |config|
+  #     config.coupon_code_normalizer_class = YourCustomNormalizer
+  #   end
+  #
+  # @example Default usage
+  #   CouponCodeNormalizer.call(" SAVE20 ") # => "save20"
+  #
+  # @example Custom case-sensitive usage
+  #   class CaseSensitiveNormalizer
+  #     def self.call(value)
+  #       value&.strip
+  #     end
+  #   end
+  #
+  #   SolidusPromotions.configure do |config|
+  #     config.coupon_code_normalizer_class = CaseSensitiveNormalizer
+  #   end
+  class CouponCodeNormalizer
+    # Normalizes the given coupon code.
+    #
+    # @param value [String, nil] the coupon code to normalize
+    # @return [String, nil] the normalized coupon code
+    def self.call(value)
+      value&.strip&.downcase
+    end
+  end
+end

data/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