spree_core 2.1.12 → 2.2.0

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

@@ -1,12 +1,10 @@
 module Spree
   class Promotion
     module Actions
-      # Responsible for the creation and management of an adjustment since an
-      # an adjustment uses its originator to also update its eligiblity and amount
       class CreateAdjustment < PromotionAction
         include Spree::Core::CalculatedAdjustments
 
-        has_many :adjustments, as: :originator
+        has_many :adjustments, as: :source
 
         delegate :eligible?, to: :promotion
 
@@ -15,32 +13,23 @@ module Spree
 
         # Creates the adjustment related to a promotion for the order passed
         # through options hash
+        #
+        # Returns `true` if an adjustment is applied to an order,
+        # `false` if the promotion has already been applied.
         def perform(options = {})
           order = options[:order]
-          return if credit_exists_on_order?(order)
-
-          self.create_adjustment("#{Spree.t(:promotion)} (#{promotion.name})", order, order)
-        end
+          return if promotion_credit_exists?(order)
 
-        # Override of CalculatedAdjustments#create_adjustment so promotional
-        # adjustments are added all the time. They will get their eligibility
-        # set to false if the amount is 0.
-        #
-        # Currently an adjustment is created even when its promotion is not eligible.
-        # This helps to figure out later which adjustments should be eligible
-        # as the order is being updated
-        #
-        # BTW The order is updated (through order#update) every time an adjustment
-        # is saved
-        def create_adjustment(label, target, calculable, mandatory=false)
-          amount = compute_amount(calculable)
-          target.adjustments.create(
+          amount = compute_amount(order)
+          return if amount == 0
+          Spree::Adjustment.create!(
             amount: amount,
-            source: calculable,
-            originator: self,
-            label: label,
-            mandatory: mandatory
+            order: order,
+            adjustable: order,
+            source: self,
+            label: "#{Spree.t(:promotion)} (#{promotion.name})"
           )
+          true
         end
 
         # Ensure a negative amount which does not exceed the sum of the order's
@@ -51,20 +40,30 @@ module Spree
         end
 
         private
+          # Tells us if there if the specified promotion is already associated with the line item
+          # regardless of whether or not its currently eligible. Useful because generally
+          # you would only want a promotion action to apply to order no more than once.
+          #
+          # Receives an adjustment +source+ (here a PromotionAction object) and tells
+          # if the order has adjustments from that already
+          def promotion_credit_exists?(adjustable)
+            self.adjustments.where(:adjustable_id => adjustable.id).exists?
+          end
+
           def ensure_action_has_calculator
             return if self.calculator
             self.calculator = Calculator::FlatPercentItemTotal.new
           end
 
           def deals_with_adjustments
-            self.adjustments.each do |adjustment|
-              if adjustment.adjustable.complete?
-                adjustment.originator = nil
-                adjustment.save
-              else
-                adjustment.destroy
-              end
-            end
+            adjustment_scope = self.adjustments.joins("LEFT OUTER JOIN spree_orders ON spree_orders.id = spree_adjustments.adjustable_id")
+            # For incomplete orders, remove the adjustment completely.
+            adjustment_scope.where("spree_orders.completed_at IS NULL").readonly(false).destroy_all
+
+            # For complete orders, the source will be invalid.
+            # Therefore we nullify the source_id, leaving the adjustment in place.
+            # This would mean that the order's total is not altered at all.
+            adjustment_scope.where("spree_orders.completed_at IS NOT NULL").update_all("source_id = NULL")
           end
       end
     end

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

@@ -0,0 +1,83 @@
+module Spree
+  class Promotion
+    module Actions
+      class CreateItemAdjustments < PromotionAction
+        include Spree::Core::CalculatedAdjustments
+
+        has_many :adjustments, as: :source
+
+        delegate :eligible?, to: :promotion
+
+        before_validation :ensure_action_has_calculator
+        before_destroy :deals_with_adjustments
+
+        def perform(payload = {})
+          order = payload[:order]
+          # Find only the 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.pluck(:adjustable_id)
+          result = false
+          order.line_items.where("id NOT IN (?)", already_adjusted_line_items).find_each do |line_item|
+            current_result = self.create_adjustment(line_item, order)
+            result ||= current_result
+          end
+          return result
+        end
+
+        def create_adjustment(adjustable, order)
+          amount = self.compute_amount(adjustable)
+          return if amount == 0
+          self.adjustments.create!(
+            amount: amount,
+            adjustable: adjustable,
+            order: order,
+            label: "#{Spree.t(:promotion)} (#{promotion.name})",
+          )
+          true
+        end
+
+        # Ensure a negative amount which does not exceed the sum of the order's
+        # item_total and ship_total
+        def compute_amount(adjustable)
+          amount = self.calculator.compute(adjustable).to_f.abs
+          [adjustable.total, amount].min * -1
+        end
+
+        private
+          # Tells us if there if the specified promotion is already associated with the line item
+          # regardless of whether or not its currently eligible. Useful because generally
+          # you would only want a promotion action to apply to line item no more than once.
+          #
+          # Receives an adjustment +source+ (here a PromotionAction object) and tells
+          # if the order has adjustments from that already
+          def promotion_credit_exists?(adjustable)
+            self.adjustments.where(:adjustable_id => adjustable.id).exists?
+          end
+
+          def ensure_action_has_calculator
+            return if self.calculator
+            self.calculator = Calculator::PercentOnLineItem.new
+          end
+
+          def deals_with_adjustments
+            adjustment_scope = Adjustment.includes(:order).references(:spree_orders)
+            # For incomplete orders, remove the adjustment completely.
+            adjustment_scope.where("spree_orders.completed_at IS NULL").each do |adjustment|
+              adjustment.destroy
+            end
+
+            # For complete orders, the source will be invalid.
+            # Therefore we nullify the source_id, leaving the adjustment in place.
+            # This would mean that the order's total is not altered at all.
+            adjustment_scope.where("spree_orders.completed_at IS NOT NULL").each do |adjustment|
+              adjustment.update_columns(
+                source_id: nil,
+                updated_at: Time.now,
+              )
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Spree
+  class Promotion
+    module Actions
+      class FreeShipping < Spree::PromotionAction
+        def perform(payload={})
+          order = payload[:order]
+
+          label = "#{Spree.t(:promotion)} (#{promotion.name})"
+          results = order.shipments.map do |shipment|
+            return false if promotion_credit_exists?(shipment)
+            shipment.adjustments.create!(
+              order: shipment.order, 
+              amount: compute_amount(shipment),
+              source: self,
+              label: label,
+            )
+            true
+          end
+          # Did we actually end up applying any adjustments?
+          # If so, then this action should be classed as 'successful'
+          results.any? { |r| r == true }
+        end
+
+        def compute_amount(shipment)
+          shipment.cost * -1
+        end
+
+        private
+
+        def promotion_credit_exists?(shipment)
+          shipment.adjustments.where(:source_id => self.id).exists?
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,10 @@ module Spree
       class FirstOrder < PromotionRule
         attr_reader :user, :email
 
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
         def eligible?(order, options = {})
           @user = order.try(:user) || options[:user]
           @email = order.email

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

@@ -9,8 +9,12 @@ module Spree
 
         OPERATORS = ['gt', 'gte']
 
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
         def eligible?(order, options = {})
-          item_total = order.line_items.map(&:amount).sum
+          item_total = order.item_total
           item_total.send(preferred_operator == 'gte' ? :>= : :>, BigDecimal.new(preferred_amount.to_s))
         end
       end

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

@@ -16,6 +16,10 @@ module Spree
           products
         end
 
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
         def eligible?(order, options = {})
           return true if eligible_products.empty?
           if preferred_match_policy == 'all'

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

@@ -2,12 +2,11 @@ module Spree
   class Promotion
     module Rules
       class User < PromotionRule
-        if Spree.user_class
-          belongs_to :user, class_name: Spree.user_class.to_s
-          has_and_belongs_to_many :users, class_name: Spree.user_class.to_s, join_table: 'spree_promotion_rules_users', foreign_key: 'promotion_rule_id'
-        else
-          belongs_to :user
-          has_and_belongs_to_many :users, join_table: 'spree_promotion_rules_users', foreign_key: 'promotion_rule_id', :class_name => Spree.user_class
+        belongs_to :user, class_name: Spree.user_class
+        has_and_belongs_to_many :users, class_name: Spree.user_class, join_table: 'spree_promotion_rules_users', foreign_key: 'promotion_rule_id'
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
         end
 
         def eligible?(order, options = {})

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

@@ -2,6 +2,10 @@ module Spree
   class Promotion
     module Rules
       class UserLoggedIn < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
         def eligible?(order, options = {})
           return order.user.present?
         end

data/app/models/spree/promotion_action.rb

@@ -2,7 +2,7 @@
 # PromotionActions perform the necessary tasks when a promotion is activated by an event and determined to be eligible.
 module Spree
   class PromotionAction < ActiveRecord::Base
-    belongs_to :promotion, foreign_key: 'activator_id', class_name: 'Spree::Promotion'
+    belongs_to :promotion, class_name: 'Spree::Promotion'
 
     scope :of_type, ->(t) { where(type: t) }
 
@@ -13,9 +13,5 @@ module Spree
     def perform(options = {})
       raise 'perform should be implemented in a sub-class of PromotionAction'
     end
-
-    def credit_exists_on_order?(order)
-      !!order.promotion_credit_exists?(self)
-    end
   end
 end

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

@@ -0,0 +1,38 @@
+module Spree
+  module PromotionHandler
+    # Decides which promotion should be activated given the current order context
+    #
+    # By activated it doesn't necessarily mean that the order will have a
+    # discount for every activated promotion. It means that the discount will be
+    # created and might eventually become eligible. The intention here is to
+    # reduce overhead. e.g. a promotion that requires item A to be eligible
+    # shouldn't be eligible unless item A is added to the order.
+    #
+    # It can be used as a wrapper for custom handlers as well. Different
+    # applications might have completely different requirements to make
+    # the promotions system accurate and performant. Here they can plug custom
+    # handler to activate promos as they wish once an item is added to cart
+    class Cart
+      attr_reader :line_item, :order
+      attr_accessor :error, :success
+
+      def initialize(order, line_item=nil)
+        @order, @line_item = order, line_item
+      end
+
+      def activate
+        promotions.each do |promotion|
+          if (line_item && promotion.eligible?(line_item)) || promotion.eligible?(order)
+            promotion.activate(line_item: line_item, order: order)
+          end
+        end
+      end
+
+      private
+
+        def promotions
+          Promotion.active.includes(:promotion_rules).where(:code => nil, :path => nil)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Spree
+  module PromotionHandler
+    class Coupon
+      attr_reader :order
+      attr_accessor :error, :success
+
+      def initialize(order)
+        @order = order
+      end
+
+      def apply
+        if order.coupon_code.present?
+          if promotion.present? && promotion.actions.exists?
+            handle_present_promotion(promotion)
+          else
+            if Promotion.with_coupon_code(order.coupon_code).try(:expired?)
+              self.error = Spree.t(:coupon_code_expired)
+            else
+              self.error = Spree.t(:coupon_code_not_found)
+            end
+          end
+        end
+
+        self
+      end
+
+      def promotion
+        @promotion ||= Promotion.active.includes(:promotion_rules, :promotion_actions).with_coupon_code(order.coupon_code)
+      end
+
+      def successful?
+        success.present? && error.blank?
+      end
+
+      private
+
+      def handle_present_promotion(promotion)
+        return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
+        return ineligible_for_this_order unless promotion.eligible?(order)
+
+        # If any of the actions for the promotion return `true`,
+        # then result here will also be `true`.
+        result = promotion.activate(:order => order)
+        if result
+          determine_promotion_application_result(result)
+        else
+          self.error = Spree.t(:coupon_code_already_applied)
+        end
+      end
+
+      def promotion_usage_limit_exceeded
+        self.error = Spree.t(:coupon_code_max_usage)
+      end
+
+      def ineligible_for_this_order
+        self.error = Spree.t(:coupon_code_not_eligible)
+      end
+
+      def determine_promotion_application_result(result)
+        detector = lambda { |p| p.source.promotion.code.downcase == order.coupon_code.downcase }
+        discount = order.line_item_adjustments.promotion.detect(&detector)
+        discount ||= order.shipment_adjustments.promotion.detect(&detector)
+        discount ||= order.adjustments.promotion.detect(&detector)
+
+        if result and discount.eligible
+          order.update_totals
+          order.persist_totals
+          self.success = Spree.t(:coupon_code_applied)
+        else
+          # if the promotion was created after the order
+          self.error = Spree.t(:coupon_code_not_found)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Spree
+  module PromotionHandler
+    # Used for activating promotions with shipping rules
+    class FreeShipping
+      attr_reader :order
+      attr_accessor :error, :success
+
+      def initialize(order)
+        @order = order
+      end
+
+      def activate
+        promotions.each do |promotion|
+          if promotion.eligible?(order)
+            promotion.activate(order: order)
+          end
+        end
+      end
+
+      private
+
+        def promotions
+          Spree::Promotion.active.where({
+            :id => Spree::Promotion::Actions::FreeShipping.pluck(:promotion_id),
+            :code => nil,
+            :path => nil
+          })
+        end
+    end
+  end
+end