solidus_friendly_promotions 1.0.0 → 1.9.0

data/app/models/concerns/solidus_friendly_promotions/{rules/line_item_applicable_order_rule.rb → conditions/line_item_applicable_order_condition.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    module LineItemApplicableOrderRule
+  module Conditions
+    module LineItemApplicableOrderCondition
       def self.included(klass)
         klass.preference :line_item_applicable, :boolean, default: true
       end

data/app/models/concerns/solidus_friendly_promotions/{rules/line_item_level_rule.rb → conditions/line_item_level_condition.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    module LineItemLevelRule
+  module Conditions
+    module LineItemLevelCondition
       def applicable?(promotable)
         promotable.is_a?(Spree::LineItem)
       end

data/app/models/concerns/solidus_friendly_promotions/{rules/order_level_rule.rb → conditions/order_level_condition.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    module OrderLevelRule
+  module Conditions
+    module OrderLevelCondition
       def applicable?(promotable)
         promotable.is_a?(Spree::Order)
       end

data/app/models/concerns/solidus_friendly_promotions/{rules/shipment_level_rule.rb → conditions/shipment_level_condition.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    module ShipmentLevelRule
+  module Conditions
+    module ShipmentLevelCondition
       def applicable?(promotable)
         promotable.is_a?(Spree::Shipment)
       end

data/app/models/solidus_friendly_promotions/{promotion_action.rb → benefit.rb}

@@ -3,20 +3,22 @@
 require "spree/preferences/persistable"
 
 module SolidusFriendlyPromotions
-  # Base class for all types of promotion action.
+  # Base class for all types of benefit.
   #
-  # PromotionActions perform the necessary tasks when a promotion is activated
+  # Benefits perform the necessary tasks when a promotion is activated
   # by an event and determined to be eligible.
-  class PromotionAction < Spree::Base
+  class Benefit < Spree::Base
     include Spree::Preferences::Persistable
     include Spree::CalculatedAdjustments
     include Spree::AdjustmentSource
     before_destroy :remove_adjustments_from_incomplete_orders
     before_destroy :raise_for_adjustments_for_completed_orders
 
-    belongs_to :promotion, inverse_of: :actions
+    belongs_to :promotion, inverse_of: :benefits
     belongs_to :original_promotion_action, class_name: "Spree::PromotionAction", optional: true
     has_many :adjustments, class_name: "Spree::Adjustment", as: :source
+    has_many :shipping_rate_discounts, class_name: "SolidusFriendlyPromotions::ShippingRateDiscount", inverse_of: :benefit
+    has_many :conditions, class_name: "SolidusFriendlyPromotions::Condition", inverse_of: :benefit, foreign_key: :benefit_id, dependent: :destroy
 
     scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
 
@@ -54,21 +56,57 @@ module SolidusFriendlyPromotions
     end
 
     def to_partial_path
-      "solidus_friendly_promotions/admin/promotion_actions/actions/#{model_name.element}"
+      "solidus_friendly_promotions/admin/benefit_fields/#{model_name.element}"
     end
 
     def level
       raise NotImplementedError
     end
 
-    def relevant_rules
-      promotion.rules.select do |rule|
-        rule.level.in?([:order, level].uniq)
-      end
+    def available_conditions
+      possible_conditions - conditions.select(&:persisted?)
     end
 
     def available_calculators
-      SolidusFriendlyPromotions.config.promotion_calculators[self.class] || (raise NotImplementedError)
+      SolidusFriendlyPromotions.config.promotion_calculators[self.class] || []
+    end
+
+    def eligible_by_applicable_conditions?(promotable, dry_run: false)
+      applicable_conditions = conditions.select do |condition|
+        condition.applicable?(promotable)
+      end
+
+      applicable_conditions.map do |applicable_condition|
+        eligible = applicable_condition.eligible?(promotable)
+
+        break [false] if !eligible && !dry_run
+
+        if dry_run
+          if applicable_condition.eligibility_errors.details[:base].first
+            code = applicable_condition.eligibility_errors.details[:base].first[:error_code]
+            message = applicable_condition.eligibility_errors.full_messages.first
+          end
+          promotion.eligibility_results.add(
+            item: promotable,
+            condition: applicable_condition,
+            success: eligible,
+            code: eligible ? nil : (code || :coupon_code_unknown_error),
+            message: eligible ? nil : (message || I18n.t(:coupon_code_unknown_error, scope: [:solidus_friendly_promotions, :eligibility_errors]))
+          )
+        end
+
+        eligible
+      end.all?
+    end
+
+    def applicable_line_items(order)
+      order.discountable_line_items.select do |line_item|
+        eligible_by_applicable_conditions?(line_item)
+      end
+    end
+
+    def possible_conditions
+      Set.new(SolidusFriendlyPromotions.config.order_conditions)
     end
 
     private

data/app/models/solidus_friendly_promotions/{actions → benefits}/adjust_line_item.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Actions
-    class AdjustLineItem < PromotionAction
+  module Benefits
+    class AdjustLineItem < Benefit
       def can_discount?(object)
         object.is_a? Spree::LineItem
       end
@@ -10,6 +10,10 @@ module SolidusFriendlyPromotions
       def level
         :line_item
       end
+
+      def possible_conditions
+        super + SolidusFriendlyPromotions.config.line_item_conditions
+      end
     end
   end
 end

data/app/models/solidus_friendly_promotions/{actions → benefits}/adjust_line_item_quantity_groups.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Actions
+  module Benefits
     class AdjustLineItemQuantityGroups < AdjustLineItem
       preference :group_size, :integer, default: 1
 
       ##
       # Computes the amount for the adjustment based on the line item and any
-      # other applicable items in the order. The rules for this specific
+      # other applicable items in the order. The conditions for this specific
       # adjustment are as follows:
       #
       # = Setup
@@ -58,7 +58,7 @@ module SolidusFriendlyPromotions
         adjustment_amount = adjustment_amount.abs
 
         order = line_item.order
-        line_items = promotion.applicable_line_items(order)
+        line_items = applicable_line_items(order)
 
         item_units = line_items.sort_by do |line_item|
           [-line_item.quantity, line_item.id]

data/app/models/solidus_friendly_promotions/{actions → benefits}/adjust_shipment.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Actions
-    class AdjustShipment < PromotionAction
+  module Benefits
+    class AdjustShipment < Benefit
       def can_discount?(object)
         object.is_a?(Spree::Shipment) || object.is_a?(Spree::ShippingRate)
       end
@@ -10,6 +10,10 @@ module SolidusFriendlyPromotions
       def level
         :shipment
       end
+
+      def possible_conditions
+        super + SolidusFriendlyPromotions.config.shipment_conditions
+      end
     end
   end
 end

data/app/models/solidus_friendly_promotions/{actions → benefits}/create_discounted_item.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Actions
-    class CreateDiscountedItem < PromotionAction
-      include OrderLevelAction
+  module Benefits
+    class CreateDiscountedItem < Benefit
+      include OrderBenefit
       preference :variant_id, :integer
       preference :quantity, :integer, default: 1
       preference :necessary_quantity, :integer, default: 1
@@ -22,19 +22,18 @@ module SolidusFriendlyPromotions
       private
 
       def find_item(order)
-        order.line_items.detect { |line_item| line_item.managed_by_order_action == self }
+        order.line_items.detect { |line_item| line_item.managed_by_order_benefit == self }
       end
 
       def create_item(order)
-        order.line_items.create!(quantity: determine_item_quantity(order), variant: variant, managed_by_order_action: self)
+        order.line_items.create!(quantity: determine_item_quantity(order), variant: variant, managed_by_order_benefit: self)
       end
 
       def determine_item_quantity(order)
-        applicable_line_items = promotion.applicable_line_items(order)
         # Integer division will floor automatically, which is what we want here:
         # 1 Item, 2 needed: 1 * 1 / 2 => 0
         # 5 items, 2 preferred, 2 needed: 5 / 2 * 2 => 4
-        applicable_line_items.sum(&:quantity) / preferred_necessary_quantity * preferred_quantity
+        applicable_line_items(order).sum(&:quantity) / preferred_necessary_quantity * preferred_quantity
       end
 
       def set_quantity(line_item, quantity)

data/app/models/solidus_friendly_promotions/calculators/distributed_amount.rb

@@ -18,7 +18,7 @@ module SolidusFriendlyPromotions
         return 0 unless line_item
         return 0 unless preferred_currency.casecmp(line_item.currency).zero?
 
-        distributable_line_items = calculable.promotion.applicable_line_items(line_item.order)
+        distributable_line_items = calculable.applicable_line_items(line_item.order)
         return 0 unless line_item.in?(distributable_line_items)
 
         DistributedAmountsHandler.new(

data/app/models/solidus_friendly_promotions/calculators/tiered_flat_rate.rb

@@ -8,7 +8,7 @@ module SolidusFriendlyPromotions
       include PromotionCalculator
 
       preference :base_amount, :decimal, default: 0
-      preference :tiers, :hash, default: {}
+      preference :tiers, :hash, default: {10 => 10}
       preference :currency, :string, default: -> { Spree::Config[:currency] }
 
       before_validation do

data/app/models/solidus_friendly_promotions/calculators/tiered_percent.rb

@@ -8,7 +8,7 @@ module SolidusFriendlyPromotions
       include PromotionCalculator
 
       preference :base_percent, :decimal, default: 0
-      preference :tiers, :hash, default: {}
+      preference :tiers, :hash, default: {50 => 5}
       preference :currency, :string, default: -> { Spree::Config[:currency] }
 
       before_validation do

data/app/models/solidus_friendly_promotions/calculators/tiered_percent_on_eligible_item_quantity.rb

@@ -3,11 +3,13 @@ require_dependency "spree/calculator"
 module SolidusFriendlyPromotions
   module Calculators
     class TieredPercentOnEligibleItemQuantity < SolidusFriendlyPromotions::Calculators::TieredPercent
+      preference :tiers, :hash, default: {10 => 5}
+
       before_validation do
         # Convert tier values to decimals. Strings don't do us much good.
         if preferred_tiers.is_a?(Hash)
           self.preferred_tiers = preferred_tiers.map do |key, value|
-            [cast_to_d(key.to_i), cast_to_d(value.to_s)]
+            [key.to_i, cast_to_d(value.to_s)]
           end.to_h
         end
       end
@@ -29,7 +31,7 @@ module SolidusFriendlyPromotions
       private
 
       def eligible_line_items_quantity_total(order)
-        calculable.promotion.applicable_line_items(order).sum(&:quantity)
+        calculable.applicable_line_items(order).sum(&:quantity)
       end
     end
   end

data/app/models/solidus_friendly_promotions/{promotion_rule.rb → condition.rb}

@@ -3,14 +3,16 @@
 require "spree/preferences/persistable"
 
 module SolidusFriendlyPromotions
-  class PromotionRule < Spree::Base
+  class Condition < Spree::Base
     include Spree::Preferences::Persistable
 
-    belongs_to :promotion
+    belongs_to :benefit, class_name: "SolidusFriendlyPromotions::Benefit", inverse_of: :conditions, optional: true
+    has_one :promotion, through: :benefit
 
     scope :of_type, ->(type) { where(type: type) }
 
-    validate :unique_per_promotion, on: :create
+    validate :unique_per_benefit, on: :create
+    validate :possible_condition_for_benefit, if: -> { benefit.present? }
 
     def preload_relations
       []
@@ -33,7 +35,7 @@ module SolidusFriendlyPromotions
     end
 
     def to_partial_path
-      "solidus_friendly_promotions/admin/promotion_rules/rules/#{model_name.element}"
+      "solidus_friendly_promotions/admin/condition_fields/#{model_name.element}"
     end
 
     def updateable?
@@ -42,10 +44,14 @@ module SolidusFriendlyPromotions
 
     private
 
-    def unique_per_promotion
-      return unless self.class.exists?(promotion_id: promotion_id, type: self.class.name)
+    def unique_per_benefit
+      return unless self.class.exists?(benefit_id: benefit_id, type: self.class.name)
 
-      errors[:base] << "Promotion already contains this rule type"
+      errors.add(:benefit, :already_contains_condition_type)
+    end
+
+    def possible_condition_for_benefit
+      benefit.possible_conditions.include?(self.class) || errors.add(:type, :invalid_condition_type)
     end
 
     def eligibility_error_message(key, options = {})

data/app/models/solidus_friendly_promotions/condition_product.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class ConditionProduct < Spree::Base
+    belongs_to :condition, class_name: "SolidusFriendlyPromotions::Condition", optional: true
+    belongs_to :product, class_name: "Spree::Product", optional: true
+  end
+end

data/app/models/solidus_friendly_promotions/condition_store.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class ConditionStore < Spree::Base
+    belongs_to :condition, class_name: "SolidusFriendlyPromotions::Condition", optional: true
+    belongs_to :store, class_name: "Spree::Store", optional: true
+  end
+end

data/app/models/solidus_friendly_promotions/condition_taxon.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class ConditionTaxon < Spree::Base
+    belongs_to :condition, class_name: "SolidusFriendlyPromotions::Condition", optional: true
+    belongs_to :taxon, class_name: "Spree::Taxon", optional: true
+  end
+end

data/app/models/solidus_friendly_promotions/{promotion_rules_user.rb → condition_user.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  class PromotionRulesUser < Spree::Base
-    belongs_to :promotion_rule, class_name: "SolidusFriendlyPromotions::PromotionRule", optional: true
+  class ConditionUser < Spree::Base
+    belongs_to :condition, class_name: "SolidusFriendlyPromotions::Condition", optional: true
     belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
   end
 end

data/app/models/solidus_friendly_promotions/{rules → conditions}/discounted_item_total.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    # A rule to apply to an order greater than (or greater than or equal to)
+  module Conditions
+    # A condition to apply to an order greater than (or greater than or equal to)
     # a specific amount after previous promotions have applied
     #
     # To add extra operators please override `self.operators_map` or any other helper method.
     # To customize the error message you can also override `ineligible_message`.
     class DiscountedItemTotal < ItemTotal
       def to_partial_path
-        "solidus_friendly_promotions/admin/promotion_rules/rules/item_total"
+        "solidus_friendly_promotions/admin/condition_fields/item_total"
       end
 
       private

data/app/models/solidus_friendly_promotions/{rules → conditions}/first_order.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class FirstOrder < PromotionRule
-      include OrderLevelRule
+  module Conditions
+    class FirstOrder < Condition
+      include OrderLevelCondition
       attr_reader :user, :email
 
       def eligible?(order, options = {})

data/app/models/solidus_friendly_promotions/{rules → conditions}/first_repeat_purchase_since.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class FirstRepeatPurchaseSince < PromotionRule
-      include OrderLevelRule
+  module Conditions
+    class FirstRepeatPurchaseSince < Condition
+      include OrderLevelCondition
 
       preference :days_ago, :integer, default: 365
       validates :preferred_days_ago, numericality: {only_integer: true, greater_than: 0}

data/app/models/solidus_friendly_promotions/{rules → conditions}/item_total.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    # A rule to apply to an order greater than (or greater than or equal to)
+  module Conditions
+    # A condition to apply to an order greater than (or greater than or equal to)
     # a specific amount
     #
     # To add extra operators please override `self.operators_map` or any other helper method.
     # To customize the error message you can also override `ineligible_message`.
-    class ItemTotal < PromotionRule
-      include OrderLevelRule
+    class ItemTotal < Condition
+      include OrderLevelCondition
 
       preference :amount, :decimal, default: 100.00
       preference :currency, :string, default: -> { Spree::Config[:currency] }
@@ -24,7 +24,7 @@ module SolidusFriendlyPromotions
 
       def self.operator_options
         operators_map.map do |name, _method|
-          [I18n.t(name, scope: "spree.item_total_rule.operators"), name]
+          [I18n.t(name, scope: "solidus_friendly_promotions.item_total_condition.operators"), name]
         end
       end
 

data/app/models/solidus_friendly_promotions/{rules → conditions}/line_item_option_value.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class LineItemOptionValue < PromotionRule
-      include LineItemLevelRule
+  module Conditions
+    class LineItemOptionValue < Condition
+      include LineItemLevelCondition
 
       preference :eligible_values, :hash
 

data/app/models/solidus_friendly_promotions/{rules → conditions}/line_item_product.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    # A rule to apply a promotion only to line items with or without a chosen product
-    class LineItemProduct < PromotionRule
-      include LineItemLevelRule
+  module Conditions
+    # A condition to apply a promotion only to line items with or without a chosen product
+    class LineItemProduct < Condition
+      include LineItemLevelCondition
 
       MATCH_POLICIES = %w[include exclude].freeze
 
-      has_many :product_promotion_rules,
+      has_many :condition_products,
         dependent: :destroy,
-        foreign_key: :promotion_rule_id,
-        class_name: "SolidusFriendlyPromotions::ProductsPromotionRule"
+        foreign_key: :condition_id,
+        class_name: "SolidusFriendlyPromotions::ConditionProduct"
       has_many :products,
         class_name: "Spree::Product",
-        through: :product_promotion_rules
+        through: :condition_products
 
       preference :match_policy, :string, default: MATCH_POLICIES.first
 

data/app/models/solidus_friendly_promotions/{rules → conditions}/line_item_taxon.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class LineItemTaxon < PromotionRule
-      include LineItemLevelRule
+  module Conditions
+    class LineItemTaxon < Condition
+      include LineItemLevelCondition
 
-      has_many :promotion_rule_taxons, class_name: "SolidusFriendlyPromotions::PromotionRulesTaxon", foreign_key: :promotion_rule_id,
+      has_many :condition_taxons, class_name: "SolidusFriendlyPromotions::ConditionTaxon", foreign_key: :condition_id,
         dependent: :destroy
-      has_many :taxons, through: :promotion_rule_taxons, class_name: "Spree::Taxon"
+      has_many :taxons, through: :condition_taxons, class_name: "Spree::Taxon"
 
       MATCH_POLICIES = %w[include exclude].freeze
 
@@ -18,7 +18,7 @@ module SolidusFriendlyPromotions
       def eligible?(line_item, _options = {})
         found = Spree::Classification.where(
           product_id: line_item.variant.product_id,
-          taxon_id: rule_taxon_ids_with_children
+          taxon_id: condition_taxon_ids_with_children
         ).exists?
 
         case preferred_match_policy
@@ -46,8 +46,8 @@ module SolidusFriendlyPromotions
 
       private
 
-      # ids of taxons rules and taxons rules children
-      def rule_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
       end
     end

data/app/models/solidus_friendly_promotions/{rules → conditions}/minimum_quantity.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    # Promotion rule for ensuring an order contains a minimum quantity of
+  module Conditions
+    # Promotion condition for ensuring an order contains a minimum quantity of
     # applicable items.
     #
-    # This promotion rule is only compatible with the "all" match policy. It
+    # This promotion condition is only compatible with the "all" match policy. It
     # doesn't make a lot of sense to use it without that policy as it reduces
     # it to a simple quantity check across the entire order which would be
-    # better served by an item total rule.
-    class MinimumQuantity < PromotionRule
-      include OrderLevelRule
+    # better served by an item total condition.
+    class MinimumQuantity < Condition
+      include OrderLevelCondition
 
       validates :preferred_minimum_quantity, numericality: {only_integer: true, greater_than: 0}
 
@@ -19,7 +19,7 @@ module SolidusFriendlyPromotions
       # Will look at all of the "applicable" line items in the order and
       # determine if the sum of their quantity is greater than the minimum.
       #
-      # "Applicable" items are ones that pass all eligibility checks of applicable rules.
+      # "Applicable" items are ones that pass all eligibility checks of applicable conditions.
       #
       # When false is returned, the reason will be included in the
       # `eligibility_errors` object.
@@ -27,7 +27,7 @@ module SolidusFriendlyPromotions
       # @param order [Spree::Order] the order we want to check eligibility on
       # @return [Boolean] true if promotion is eligible, false otherwise
       def eligible?(order)
-        if promotion.applicable_line_items(order).sum(&:quantity) < preferred_minimum_quantity
+        if benefit.applicable_line_items(order).sum(&:quantity) < preferred_minimum_quantity
           eligibility_errors.add(
             :base,
             eligibility_error_message(:quantity_less_than_minimum, count: preferred_minimum_quantity),

data/app/models/solidus_friendly_promotions/{rules → conditions}/nth_order.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class NthOrder < PromotionRule
-      include OrderLevelRule
+  module Conditions
+    class NthOrder < Condition
+      include OrderLevelCondition
 
       preference :nth_order, :integer, default: 2
       # It does not make sense to have this apply to the first order using preferred_nth_order == 1
-      # Instead we could use the first_order rule
+      # Instead we could use the first_order condition
       validates :preferred_nth_order, numericality: {only_integer: true, greater_than: 1}
 
       # This is never eligible if the order does not have a user, and that user does not have any previous completed orders.
       #
-      # Use the first order rule if you want a promotion to be applied to the first order for a user.
+      # Use the first order condition if you want a promotion to be applied to the first order for a user.
       # @param order [Spree::Order]
       def eligible?(order, _options = {})
         return false unless order.user

data/app/models/solidus_friendly_promotions/{rules → conditions}/one_use_per_user.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class OneUsePerUser < PromotionRule
-      include OrderLevelRule
+  module Conditions
+    class OneUsePerUser < Condition
+      include OrderLevelCondition
 
       def eligible?(order, _options = {})
         if order.user.present?

data/app/models/solidus_friendly_promotions/{rules → conditions}/option_value.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class OptionValue < PromotionRule
-      include LineItemApplicableOrderRule
+  module Conditions
+    class OptionValue < Condition
+      include LineItemApplicableOrderCondition
 
       preference :eligible_values, :hash