spree_core 2.3.13 → 2.4.0.rc1

data/app/models/spree/promotion/actions/create_adjustment.rb

@@ -2,8 +2,8 @@ module Spree
   class Promotion
     module Actions
       class CreateAdjustment < PromotionAction
-        include Spree::Core::CalculatedAdjustments
-        include Spree::Core::AdjustmentSource
+        include Spree::CalculatedAdjustments
+        include Spree::AdjustmentSource
 
         has_many :adjustments, as: :source
 

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -2,8 +2,8 @@ module Spree
   class Promotion
     module Actions
       class CreateItemAdjustments < PromotionAction
-        include Spree::Core::CalculatedAdjustments
-        include Spree::Core::AdjustmentSource
+        include Spree::CalculatedAdjustments
+        include Spree::AdjustmentSource
 
         has_many :adjustments, as: :source
 
@@ -14,14 +14,11 @@ module Spree
 
         def perform(payload = {})
           order = payload[:order]
-          # Find only the orders' line items which have not already been adjusted by this promotion
-          # HACK: Need to use [0] because `pluck` may return an empty array, which AR helpfully
-          # coverts to meaning NOT IN (NULL) and the DB isn't happy about that.
-          already_adjusted_line_items = [0] + self.adjustments.
-            where(adjustable_id: order.line_items.pluck(:id), adjustable_type: 'Spree::LineItem').
-            pluck(:adjustable_id)
+          promotion = payload[:promotion]
+
           result = false
-          order.line_items.where("id NOT IN (?)", already_adjusted_line_items).find_each do |line_item|
+
+          line_items_to_adjust(promotion, order).each do |line_item|
             current_result = self.create_adjustment(line_item, order)
             result ||= current_result
           end
@@ -31,7 +28,6 @@ module Spree
         def create_adjustment(adjustable, order)
           amount = self.compute_amount(adjustable)
           return if amount == 0
-          return if promotion.product_ids.present? and !promotion.product_ids.include?(adjustable.product.id)
           self.adjustments.create!(
             amount: amount,
             adjustable: adjustable,
@@ -44,8 +40,9 @@ module Spree
         # Ensure a negative amount which does not exceed the sum of the order's
         # item_total and ship_total
         def compute_amount(adjustable)
+          return 0 unless promotion.line_item_actionable? adjustable.order, adjustable
           promotion_amount = self.calculator.compute(adjustable).to_f.abs
-
+          
           [adjustable.amount, promotion_amount].min * -1
         end
 
@@ -65,6 +62,13 @@ module Spree
             self.calculator = Calculator::PercentOnLineItem.new
           end
 
+          def line_items_to_adjust(promotion, order)
+            excluded_ids = self.adjustments.pluck(:adjustable_id)
+            order.line_items.where.not(id: excluded_ids).select do |line_item|
+              promotion.line_item_actionable? order, line_item
+            end
+          end
+
       end
     end
   end

data/app/models/spree/promotion/actions/create_line_items.rb

@@ -39,23 +39,13 @@ module Spree
           order = options[:order]
           return unless self.eligible? order
 
-          action_taken = false
           promotion_action_line_items.each do |item|
             current_quantity = order.quantity_of(item.variant)
-            if current_quantity < item.quantity && item_available?(item)
-              line_item = order.contents.add(item.variant, item.quantity - current_quantity)
-              action_taken = true if line_item.try(:valid?)
+            if current_quantity < item.quantity
+              order.contents.add(item.variant, item.quantity - current_quantity)
             end
           end
-          action_taken
         end
-
-        # Checks that there's enough stock to add the line item to the order
-        def item_available?(item)
-          quantifier = Spree::Stock::Quantifier.new(item.variant)
-          quantifier.can_supply? item.quantity
-        end
-
       end
     end
   end

data/app/models/spree/promotion/rules/first_order.rb

@@ -13,10 +13,14 @@ module Spree
           @email = order.email
 
           if user || email
-            completed_orders.blank? || (completed_orders.first == order)
+            if !completed_orders.blank? && completed_orders.first != order
+              eligibility_errors.add(:base, eligibility_error_message(:not_first_order))
+            end
           else
-            false
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_or_email_specified))
           end
+
+          eligibility_errors.empty?
         end
 
         private

data/app/models/spree/promotion/rules/item_total.rb

@@ -4,10 +4,14 @@ module Spree
   class Promotion
     module Rules
       class ItemTotal < PromotionRule
-        preference :amount, :decimal, default: 100.00
-        preference :operator, :string, default: '>'
+        preference :amount_min, :decimal, default: 100.00
+        preference :operator_min, :string, default: '>'
+        preference :amount_max, :decimal, default: 1000.00
+        preference :operator_max, :string, default: '<'
 
-        OPERATORS = ['gt', 'gte']
+
+        OPERATORS_MIN = ['gt', 'gte']
+        OPERATORS_MAX = ['lt','lte']
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
@@ -15,8 +19,42 @@ module Spree
 
         def eligible?(order, options = {})
           item_total = order.item_total
-          item_total.send(preferred_operator == 'gte' ? :>= : :>, BigDecimal.new(preferred_amount.to_s))
+
+          lower_limit_condition = item_total.send(preferred_operator_min == 'gte' ? :>= : :>, BigDecimal.new(preferred_amount_min.to_s))
+          upper_limit_condition = item_total.send(preferred_operator_max == 'lte' ? :<= : :<, BigDecimal.new(preferred_amount_max.to_s))
+
+          eligibility_errors.add(:base, ineligible_message_max) unless upper_limit_condition
+          eligibility_errors.add(:base, ineligible_message_min) unless lower_limit_condition
+
+          eligibility_errors.empty?
+        end
+
+        private
+        def formatted_amount_min
+          Spree::Money.new(preferred_amount_min).to_s
+        end
+
+        def formatted_amount_max
+          Spree::Money.new(preferred_amount_max).to_s
+        end
+
+
+        def ineligible_message_max
+          if preferred_operator_max == 'gte'
+            eligibility_error_message(:item_total_more_than_or_equal, amount: formatted_amount_max)
+          else
+            eligibility_error_message(:item_total_more_than, amount: formatted_amount_max)
+          end
         end
+
+        def ineligible_message_min
+          if preferred_operator_min == 'gte'
+            eligibility_error_message(:item_total_less_than, amount: formatted_amount_min)
+          else
+            eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount_min)
+          end
+        end
+
       end
     end
   end

data/app/models/spree/promotion/rules/one_use_per_user.rb

@@ -0,0 +1,24 @@
+module Spree
+  class Promotion
+    module Rules
+      class OneUsePerUser < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          if order.user.present?
+            if promotion.used_by?(order.user, [order])
+              eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user))
+            end
+          else
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end
+

data/app/models/spree/promotion/rules/product.rb

@@ -21,24 +21,26 @@ module Spree
 
         def eligible?(order, options = {})
           return true if eligible_products.empty?
+
           if preferred_match_policy == 'all'
-            eligible_products.all? {|p| order.products.include?(p) }
+            unless eligible_products.all? {|p| order.products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(:missing_product))
+            end
           elsif preferred_match_policy == 'any'
-            order.products.any? {|p| eligible_products.include?(p) }
+            unless order.products.any? {|p| eligible_products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products))
+            end
           else
-            order.products.none? {|p| eligible_products.include?(p) }
+            unless order.products.none? {|p| eligible_products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product))
+            end
           end
+
+          eligibility_errors.empty?
         end
 
         def actionable?(line_item)
-          case preferred_match_policy
-          when 'any', 'all'
-            product_ids.include? line_item.variant.product_id
-          when 'none'
-            product_ids.exclude? line_item.variant.product_id
-          else
-            raise "unexpected match policy: #{preferred_match_policy.inspect}"
-          end
+          product_ids.include? line_item.variant.product_id
         end
 
         def product_ids_string

data/app/models/spree/promotion/rules/taxon.rb

@@ -0,0 +1,61 @@
+module Spree
+  class Promotion
+    module Rules
+      class Taxon < PromotionRule
+        has_and_belongs_to_many :taxons, class_name: '::Spree::Taxon', join_table: 'spree_taxons_promotion_rules', foreign_key: 'promotion_rule_id'
+
+        MATCH_POLICIES = %w(any all)
+        preference :match_policy, default: MATCH_POLICIES.first
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          if preferred_match_policy == 'all'
+            unless (taxons.to_a - taxons_in_order_including_parents(order)).empty?
+              eligibility_errors.add(:base, eligibility_error_message(:missing_taxon))
+            end
+          else
+            order_taxons = taxons_in_order_including_parents(order)
+            unless taxons.any?{ |taxon| order_taxons.include? taxon }
+              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
+            end
+          end
+
+          eligibility_errors.empty?
+        end
+
+        def taxon_ids_string
+          taxons.pluck(:id).join(',')
+        end
+
+        def taxon_ids_string=(s)
+          ids = s.to_s.split(',').map(&:strip)
+          self.taxons = Spree::Taxon.find(ids)
+        end
+
+        private
+
+        # All taxons in an order
+        def order_taxons(order)
+          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).uniq
+        end
+
+        # ids of taxons rules and taxons rules children
+        def taxons_including_children_ids
+          taxons.inject([]){ |ids,taxon| ids += taxon.self_and_descendants.ids }
+        end
+
+        # taxons order vs taxons rules and taxons rules children
+        def order_taxons_in_taxons_and_children(order)
+          order_taxons(order).where(id: taxons_including_children_ids)
+        end
+
+        def taxons_in_order_including_parents(order)
+          order_taxons_in_taxons_and_children(order).inject([]){ |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
+        end
+      end
+    end
+  end
+end

data/app/models/spree/promotion/rules/user.rb

@@ -8,7 +8,7 @@ module Spree
           join_table: 'spree_promotion_rules_users',
           foreign_key: 'promotion_rule_id',
           association_foreign_key: :user_id
-        
+
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end

data/app/models/spree/promotion/rules/user_logged_in.rb

@@ -7,7 +7,10 @@ module Spree
         end
 
         def eligible?(order, options = {})
-          return order.user.present?
+          unless order.user.present?
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
+          end
+          eligibility_errors.empty?
         end
       end
     end

data/app/models/spree/promotion_category.rb

@@ -0,0 +1,6 @@
+module Spree
+  class PromotionCategory < Spree::Base
+    validates_presence_of :name
+    has_many :promotions
+  end
+end

data/app/models/spree/promotion_handler/cart.rb

@@ -29,26 +29,22 @@ module Spree
       end
 
       private
+        def promotions
+          promo_table = Promotion.arel_table
+          join_table = Arel::Table.new(:spree_orders_promotions)
 
-      def promotions
-        # AR cannot bind raw ASTs to prepared statements. There always must be a manager around.
-        # Also Postgresql requires an aliased table for `SELECT * FROM (subexpression) AS alias`.
-        # And Sqlite3 cannot work on outher parenthesis from `(left UNION right)`.
-        # So this construct makes both happy.
-        select = Arel::SelectManager.new(
-          Promotion,
-          Promotion.arel_table.create_table_alias(
-            order.promotions.active.union(Promotion.active.where(code: nil, path: nil)),
-            Promotion.table_name
-          ),
-        )
-        select.project(Arel.star)
+          join_condition = promo_table.join(join_table, Arel::Nodes::OuterJoin).on(
+            promo_table[:id].eq(join_table[:promotion_id])
+          ).join_sources
 
-        Promotion.find_by_sql(
-          select,
-          order.promotions.bind_values
-        )
-      end
+          Promotion.active.includes(:promotion_rules).
+            joins(join_condition).
+            where(
+              promo_table[:code].eq(nil).and(
+                promo_table[:path].eq(nil)
+              ).or(join_table[:order_id].eq(order.id))
+            ).distinct
+        end
     end
   end
 end

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

@@ -2,7 +2,7 @@ module Spree
   module PromotionHandler
     class Coupon
       attr_reader :order
-      attr_accessor :error, :success
+      attr_accessor :error, :success, :status_code
 
       def initialize(order)
         @order = order
@@ -14,9 +14,9 @@ module Spree
             handle_present_promotion(promotion)
           else
             if Promotion.with_coupon_code(order.coupon_code).try(:expired?)
-              self.error = Spree.t(:coupon_code_expired)
+              set_error_code :coupon_code_expired
             else
-              self.error = Spree.t(:coupon_code_not_found)
+              set_error_code :coupon_code_not_found
             end
           end
         end
@@ -24,6 +24,16 @@ module Spree
         self
       end
 
+      def set_success_code(c)
+        @status_code = c
+        @success = Spree.t(c)
+      end
+
+      def set_error_code(c)
+        @status_code = c
+        @error = Spree.t(c)
+      end
+
       def promotion
         @promotion ||= Promotion.active.includes(:promotion_rules, :promotion_actions).with_coupon_code(order.coupon_code)
       end
@@ -37,7 +47,10 @@ module Spree
       def handle_present_promotion(promotion)
         return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
         return promotion_applied if promotion_exists_on_order?(order, promotion)
-        return ineligible_for_this_order unless promotion.eligible?(order)
+        unless promotion.eligible?(order)
+          self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
+          return (self.error || ineligible_for_this_order)
+        end
 
         # If any of the actions for the promotion return `true`,
         # then result here will also be `true`.
@@ -45,20 +58,20 @@ module Spree
         if result
           determine_promotion_application_result
         else
-          self.error = Spree.t(:coupon_code_unknown_error)
+          set_error_code :coupon_code_unknown_error
         end
       end
 
       def promotion_usage_limit_exceeded
-        self.error = Spree.t(:coupon_code_max_usage)
+        set_error_code :coupon_code_max_usage
       end
 
       def ineligible_for_this_order
-        self.error = Spree.t(:coupon_code_not_eligible)
+        set_error_code :coupon_code_not_eligible
       end
 
       def promotion_applied
-        self.error = Spree.t(:coupon_code_already_applied)
+        set_error_code :coupon_code_already_applied
       end
 
       def promotion_exists_on_order?(order, promotion)
@@ -72,26 +85,22 @@ module Spree
           end
         }
 
-        # Check for applied adjustments.
         discount = order.line_item_adjustments.promotion.detect(&detector)
         discount ||= order.shipment_adjustments.promotion.detect(&detector)
         discount ||= order.adjustments.promotion.detect(&detector)
 
-        # Check for applied line items.
-        created_line_items = promotion.actions.detect { |a| a.type == 'Spree::Promotion::Actions::CreateLineItems' }
-
-        if (discount && discount.eligible) || created_line_items
+        if discount.eligible
           order.update_totals
           order.persist_totals
-          self.success = Spree.t(:coupon_code_applied)
+          set_success_code :coupon_code_applied
         else
           # if the promotion exists on an order, but wasn't found above,
           # we've already selected a better promotion
           if order.promotions.with_coupon_code(order.coupon_code)
-            self.error = Spree.t(:coupon_code_better_exists)
+            set_error_code :coupon_code_better_exists
           else
             # if the promotion was created after the order
-            self.error = Spree.t(:coupon_code_not_found)
+            set_error_code :coupon_code_not_found
           end
         end
       end