solidus_promotions 4.6.2 → 4.7.0

data/app/models/solidus_promotions/conditions/order_option_value.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class OrderOptionValue < Condition
+      include OptionValueCondition
+
+      def order_eligible?(order, _options = {})
+        order.line_items.any? do |line_item|
+          LineItemOptionValue.new(preferred_eligible_values: preferred_eligible_values).eligible?(line_item)
+        end
+      end
+
+      def to_partial_path
+        "solidus_promotions/admin/condition_fields/option_value"
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/order_product.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    # A condition to limit a promotion based on products in the order.  Can
+    # require all or any of the products to be present.  Valid products
+    # either come from assigned product group or are assingned directly to
+    # the condition.
+    class OrderProduct < Condition
+      include ProductCondition
+
+      MATCH_POLICIES = %w[any all none only].freeze
+
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      # scope/association that is used to test eligibility
+      def eligible_products
+        products
+      end
+
+      def order_eligible?(order)
+        return true if eligible_products.empty?
+
+        case preferred_match_policy
+        when "all"
+          unless eligible_products.all? { |product| order_products(order).include?(product) }
+            eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
+          end
+        when "any"
+          unless order_products(order).any? { |product| eligible_products.include?(product) }
+            eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products),
+              error_code: :no_applicable_products)
+          end
+        when "none"
+          unless order_products(order).none? { |product| eligible_products.include?(product) }
+            eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
+              error_code: :has_excluded_product)
+          end
+        when "only"
+          unless order_products(order).all? { |product| eligible_products.include?(product) }
+            eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
+              error_code: :has_excluded_product)
+          end
+        end
+
+        eligibility_errors.empty?
+      end
+
+      def to_partial_path
+        "solidus_promotions/admin/condition_fields/product"
+      end
+
+      private
+
+      def order_products(order)
+        order.line_items.map(&:variant).map(&:product)
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/order_taxon.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class OrderTaxon < Condition
+      include TaxonCondition
+
+      MATCH_POLICIES = %w[any all none].freeze
+
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def order_eligible?(order, _options = {})
+        line_item_taxon_ids = taxon_ids_in_order(order)
+
+        case preferred_match_policy
+        when "all"
+          unless taxon_ids_with_children.all? { |taxon_and_descendant_ids| (line_item_taxon_ids & taxon_and_descendant_ids).any? }
+
+            eligibility_errors.add(:base, eligibility_error_message(:missing_taxon), error_code: :missing_taxon)
+          end
+        when "any"
+          if taxon_ids_with_children.none? { |taxon_and_descendant_ids| (line_item_taxon_ids & taxon_and_descendant_ids).any? }
+
+            eligibility_errors.add(
+              :base,
+              eligibility_error_message(:no_matching_taxons),
+              error_code: :no_matching_taxons
+            )
+          end
+        when "none"
+          if taxon_ids_with_children.any? { |taxon_and_descendant_ids| (line_item_taxon_ids & taxon_and_descendant_ids).any? }
+
+            eligibility_errors.add(
+              :base,
+              eligibility_error_message(:has_excluded_taxon),
+              error_code: :has_excluded_taxon
+            )
+          end
+        end
+
+        eligibility_errors.empty?
+      end
+
+      def to_partial_path
+        "solidus_promotions/admin/condition_fields/taxon"
+      end
+
+      private
+
+      # All taxon IDs in an order
+      def taxon_ids_in_order(order)
+        order.line_items.flat_map do |line_item|
+          line_item.variant.product.classifications.map(&:taxon_id)
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/price_option_value.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class PriceOptionValue < Condition
+      include OptionValueCondition
+
+      def price_eligible?(price, _options = {})
+        pid = price.variant.product_id
+        ovids = price.variant.option_value_ids
+
+        product_ids.include?(pid) && (value_ids(pid) & ovids).present?
+      end
+
+      private
+
+      def product_ids
+        preferred_eligible_values.keys
+      end
+
+      def value_ids(product_id)
+        preferred_eligible_values[product_id]
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/price_product.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    # A condition to apply a promotion only to prices with or without selected products
+    class PriceProduct < Condition
+      include ProductCondition
+
+      MATCH_POLICIES = %w[include exclude].freeze
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def price_eligible?(price, _options = {})
+        price_matches_products = products.include?(price.variant.product)
+        success = exclude_configured_products? ? !price_matches_products : price_matches_products
+
+        unless success
+          message_code = exclude_configured_products? ? :has_excluded_product : :no_applicable_products
+          eligibility_errors.add(
+            :base,
+            eligibility_error_message(message_code),
+            error_code: message_code
+          )
+        end
+
+        success
+      end
+
+      private
+
+      def exclude_configured_products?
+        preferred_match_policy == "exclude"
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/price_taxon.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class PriceTaxon < Condition
+      include TaxonCondition
+
+      MATCH_POLICIES = %w[include exclude].freeze
+
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def price_eligible?(price, _options = {})
+        price_taxon_ids = price.variant.product.classifications.map(&:taxon_id)
+
+        case preferred_match_policy
+        when "include"
+          taxon_ids_with_children.any? { |taxon_and_descendant_ids| (price_taxon_ids & taxon_and_descendant_ids).any? }
+        when "exclude"
+          taxon_ids_with_children.none? { |taxon_and_descendant_ids| (price_taxon_ids & taxon_and_descendant_ids).any? }
+        else
+          raise "unexpected match policy: #{preferred_match_policy.inspect}"
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/product.rb

@@ -9,77 +9,35 @@ module SolidusPromotions
     class Product < Condition
       include LineItemApplicableOrderLevelCondition
 
-      has_many :condition_products,
-        dependent: :destroy,
-        foreign_key: :condition_id,
-        class_name: "SolidusPromotions::ConditionProduct",
-        inverse_of: :condition
-      has_many :products, class_name: "Spree::Product", through: :condition_products
-
-      def preload_relations
-        [:products]
-      end
+      include ProductCondition
 
       MATCH_POLICIES = %w[any all none only].freeze
 
-      validates :preferred_match_policy, inclusion: { in: MATCH_POLICIES }
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
 
       preference :match_policy, :string, default: MATCH_POLICIES.first
 
-      # scope/association that is used to test eligibility
-      def eligible_products
-        products
-      end
-
-      def order_eligible?(order)
-        return true if eligible_products.empty?
-
-        case preferred_match_policy
-        when "all"
-          unless eligible_products.all? { |product| order_products(order).include?(product) }
-            eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
-          end
-        when "any"
-          unless order_products(order).any? { |product| eligible_products.include?(product) }
-            eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products),
-              error_code: :no_applicable_products)
-          end
-        when "none"
-          unless order_products(order).none? { |product| eligible_products.include?(product) }
-            eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
-              error_code: :has_excluded_product)
-          end
-        when "only"
-          unless order_products(order).all? { |product| eligible_products.include?(product) }
-            eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
-              error_code: :has_excluded_product)
-          end
-        else
-          raise "unexpected match policy: #{preferred_match_policy.inspect}"
-        end
-
+      def order_eligible?(order, _options = {})
+        order_condition = OrderProduct.new(products:, preferred_match_policy:)
+        order_condition.order_eligible?(order)
+        @eligibility_errors = order_condition.eligibility_errors
         eligibility_errors.empty?
       end
 
       def line_item_eligible?(line_item, _options = {})
-        # The order level eligibility check happens first, and if none of the products
-        # are in the order, then no line items should be available to check.
-        raise "This should not happen" if preferred_match_policy == "none"
-        product_ids.include?(line_item.variant.product_id)
-      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)
+        line_item_match_policy = preferred_match_policy.in?(%w[any all only]) ? "include" : "exclude"
+        line_item_condition = LineItemProduct.new(products:, preferred_match_policy: line_item_match_policy)
+        line_item_condition.line_item_eligible?(line_item)
+        @eligibility_errors = line_item_condition.eligibility_errors
+        eligibility_errors.empty?
       end
 
-      private
-
-      def order_products(order)
-        order.line_items.map(&:variant).map(&:product)
+      def price_eligible?(price, _options = {})
+        price_match_policy = preferred_match_policy.in?(%w[any all only]) ? "include" : "exclude"
+        price_condition = PriceProduct.new(products:, preferred_match_policy: price_match_policy)
+        price_condition.price_eligible?(price)
+        @eligibility_errors = price_condition.eligibility_errors
+        eligibility_errors.empty?
       end
     end
   end

data/app/models/solidus_promotions/conditions/shipping_method.rb

@@ -3,17 +3,15 @@
 module SolidusPromotions
   module Conditions
     class ShippingMethod < Condition
+      # TODO: Remove in Solidus 5
       include ShipmentLevelCondition
 
       preference :shipping_method_ids, type: :array, default: []
 
-      def applicable?(promotable)
-        promotable.is_a?(Spree::Shipment) || promotable.is_a?(Spree::ShippingRate)
-      end
-
-      def eligible?(promotable)
+      def shipment_eligible?(promotable, _options = {})
         promotable.shipping_method&.id&.in?(preferred_shipping_method_ids.map(&:to_i))
       end
+      alias_method :shipping_rate_eligible?, :shipment_eligible?
     end
   end
 end

data/app/models/solidus_promotions/conditions/store.rb

@@ -3,6 +3,7 @@
 module SolidusPromotions
   module Conditions
     class Store < Condition
+      # TODO: Remove in Solidus 5
       include OrderLevelCondition
 
       has_many :condition_stores,
@@ -16,7 +17,7 @@ module SolidusPromotions
         [:stores]
       end
 
-      def eligible?(order, _options = {})
+      def order_eligible?(order, _options = {})
         stores.none? || stores.include?(order.store)
       end
 

data/app/models/solidus_promotions/conditions/taxon.rb

@@ -5,96 +5,47 @@ module SolidusPromotions
     class Taxon < Condition
       include LineItemApplicableOrderLevelCondition
 
-      has_many :condition_taxons,
-        class_name: "SolidusPromotions::ConditionTaxon",
-        foreign_key: :condition_id,
-        dependent: :destroy,
-        inverse_of: :condition
-      has_many :taxons, through: :condition_taxons, class_name: "Spree::Taxon"
-
-      def preload_relations
-        [:taxons]
-      end
+      include TaxonCondition
 
       MATCH_POLICIES = %w[any all none].freeze
 
-      validates :preferred_match_policy, inclusion: { in: MATCH_POLICIES }
+      validates :preferred_match_policy, inclusion: {in: MATCH_POLICIES}
 
       preference :match_policy, :string, default: MATCH_POLICIES.first
 
-      def order_eligible?(order)
-        order_taxons = taxons_in_order(order)
-
-        case preferred_match_policy
-        when "all"
-          matches_all = taxons.all? do |condition_taxon|
-            order_taxons.where(id: condition_taxon.self_and_descendants.ids).exists?
-          end
+      def order_eligible?(order, _options = {})
+        order_condition = OrderTaxon.new(taxons:, preferred_match_policy:)
 
-          unless matches_all
-            eligibility_errors.add(:base, eligibility_error_message(:missing_taxon), error_code: :missing_taxon)
-          end
-        when "any"
-          unless order_taxons.where(id: condition_taxon_ids_with_children).exists?
-            eligibility_errors.add(
-              :base,
-              eligibility_error_message(:no_matching_taxons),
-              error_code: :no_matching_taxons
-            )
-          end
-        when "none"
-          if order_taxons.where(id: condition_taxon_ids_with_children).exists?
-            eligibility_errors.add(
-              :base,
-              eligibility_error_message(:has_excluded_taxon),
-              error_code: :has_excluded_taxon
-            )
-          end
-        else
-          raise "unexpected match policy: #{preferred_match_policy.inspect}"
-        end
+        # Hydrate the instance cache with our @taxon_ids_with_children cache
+        order_condition.taxons_ids_with_children = taxon_ids_with_children
 
+        order_condition.order_eligible?(order)
+        @eligibility_errors = order_condition.eligibility_errors
         eligibility_errors.empty?
       end
 
-      def line_item_eligible?(line_item)
-        # The order level eligibility check happens first, and if none of the taxons
-        # are in the order, then no line items should be available to check.
-        raise "This should not happen" if preferred_match_policy == "none"
-
-        raise "unexpected match policy: #{preferred_match_policy.inspect}" unless preferred_match_policy.in?(MATCH_POLICIES)
-
-        Spree::Classification.where(
-          product_id: line_item.variant.product_id,
-          taxon_id: condition_taxon_ids_with_children
-        ).exists?
-      end
-
-      def taxon_ids_string
-        taxon_ids.join(",")
-      end
+      def line_item_eligible?(line_item, _options = {})
+        line_item_match_policy = preferred_match_policy.in?(%w[any all]) ? "include" : "exclude"
+        line_item_condition = LineItemTaxon.new(taxons:, preferred_match_policy: line_item_match_policy)
 
-      def taxon_ids_string=(taxon_ids)
-        self.taxon_ids = taxon_ids.to_s.split(",").map(&:strip)
-      end
+        # Hydrate the instance cache with our @taxon_ids_with_children cache\
+        line_item_condition.taxons_ids_with_children = taxon_ids_with_children
 
-      def updateable?
-        true
+        result = line_item_condition.line_item_eligible?(line_item)
+        @eligibility_errors = line_item_condition.eligibility_errors
+        result
       end
 
-      private
+      def price_eligible?(price, _options = {})
+        price_match_policy = preferred_match_policy.in?(%w[any all]) ? "include" : "exclude"
+        price_condition = PriceTaxon.new(taxons:, preferred_match_policy: price_match_policy)
 
-      # All taxons in an order
-      def taxons_in_order(order)
-        Spree::Taxon
-          .joins(products: { variants_including_master: :line_items })
-          .where(spree_line_items: { order_id: order.id })
-          .distinct
-      end
+        # Hydrate the instance cache with our @taxon_ids_with_children cache
+        price_condition.taxons_ids_with_children = taxon_ids_with_children
 
-      # ids of taxons conditions and taxons conditions children
-      def condition_taxon_ids_with_children
-        taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
+        result = price_condition.price_eligible?(price)
+        @eligibility_errors = price_condition.eligibility_errors
+        result
       end
     end
   end

data/app/models/solidus_promotions/conditions/user.rb

@@ -3,6 +3,7 @@
 module SolidusPromotions
   module Conditions
     class User < Condition
+      # TODO: Remove in Solidus 5
       include OrderLevelCondition
 
       has_many :condition_users,
@@ -16,7 +17,7 @@ module SolidusPromotions
         [:users]
       end
 
-      def eligible?(order, _options = {})
+      def order_eligible?(order, _options = {})
         users.include?(order.user)
       end
 

data/app/models/solidus_promotions/conditions/user_logged_in.rb

@@ -3,9 +3,7 @@
 module SolidusPromotions
   module Conditions
     class UserLoggedIn < Condition
-      include OrderLevelCondition
-
-      def eligible?(order, _options = {})
+      def order_eligible?(order, _options = {})
         if order.user.blank?
           eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
         end

data/app/models/solidus_promotions/conditions/user_role.rb

@@ -3,14 +3,12 @@
 module SolidusPromotions
   module Conditions
     class UserRole < Condition
-      include OrderLevelCondition
-
       preference :role_ids, :array, default: []
 
       MATCH_POLICIES = %w[any all].freeze
       preference :match_policy, default: MATCH_POLICIES.first
 
-      def eligible?(order, _options = {})
+      def order_eligible?(order, _options = {})
         return false unless order.user
 
         if all_match_policy?

data/app/models/solidus_promotions/distributed_amounts_handler.rb

@@ -12,7 +12,7 @@ module SolidusPromotions
     # @param line_item [LineItem] one of the line_items distributed over
     # @return [BigDecimal] the weighted adjustment for this line_item
     def amount(line_item)
-      distributed_amounts[line_item.id].to_d
+      distributed_amounts[line_item].to_d
     end
 
     private
@@ -21,11 +21,7 @@ module SolidusPromotions
     # @return [Hash<Integer, BigDecimal>] a hash of line item IDs and their
     #   corresponding weighted adjustments
     def distributed_amounts
-      line_item_ids.zip(allocated_amounts).to_h
-    end
-
-    def line_item_ids
-      line_items.map(&:id)
+      line_items.zip(allocated_amounts).to_h
     end
 
     def elligible_amounts

data/app/models/solidus_promotions/eligibility_results.rb

@@ -3,6 +3,7 @@
 module SolidusPromotions
   class EligibilityResults
     include Enumerable
+
     attr_reader :results, :promotion
 
     def initialize(promotion)

data/app/models/solidus_promotions/item_discount.rb

@@ -12,6 +12,7 @@ module SolidusPromotions
   # @attr_reader [BigDecimal] amount the amount of discount applied to the item
   class ItemDiscount
     include ActiveModel::Model
+
     attr_accessor :item, :label, :source, :amount
 
     def ==(other)