dup_spree_promo 1.3.0.rc1

data/app/models/spree/calculator/percent_per_item.rb

@@ -0,0 +1,48 @@
+module Spree
+
+  # A calculator for promotions that calculates a percent-off discount
+  # for all matching products in an order. This should not be used as a 
+  # shipping calculator since it would be the same thing as a flat percent
+  # off the entire order.
+  
+  class Calculator::PercentPerItem < Calculator
+    preference :percent, :decimal, :default => 0
+
+    attr_accessible :preferred_percent
+
+    def self.description
+      I18n.t(:percent_per_item)
+    end
+
+    def compute(object=nil)
+      return 0 if object.nil?
+      object.line_items.reduce(0) do |sum, line_item|
+        sum += value_for_line_item(line_item)
+      end
+    end
+
+  private
+
+    # Returns all products that match the promotion's rule. 
+    def matching_products
+      @matching_products ||= if compute_on_promotion?
+        self.calculable.promotion.rules.map(&:products).flatten
+      end
+    end
+
+    # Calculates the discount value of each line item. Returns zero 
+    # unless the product is included in the promotion rules.
+    def value_for_line_item(line_item)
+      if compute_on_promotion?
+        return 0 unless matching_products.include?(line_item.product)
+      end
+      line_item.price * line_item.quantity * preferred_percent
+    end
+
+    # Determines wether or not the calculable object is a promotion
+    def compute_on_promotion?
+      @compute_on_promotion ||= self.calculable.respond_to?(:promotion)
+    end
+
+  end
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,19 @@
+Spree::Order.class_eval do
+  attr_accessible :coupon_code
+  attr_reader :coupon_code
+
+  def coupon_code=(code)
+    @coupon_code = code.strip.downcase rescue nil
+  end
+
+  # Tells us if there if the specified promotion is already associated with the order
+  # regardless of whether or not its currently eligible.  Useful because generally
+  # you would only want a promotion to apply to order no more than once.
+  def promotion_credit_exists?(promotion)
+    !! adjustments.promotion.reload.detect { |credit| credit.originator.promotion.id == promotion.id }
+  end
+
+  def promo_total
+    adjustments.eligible.promotion.map(&:amount).sum
+  end
+end

data/app/models/spree/order_updater_decorator.rb

@@ -0,0 +1,14 @@
+Spree::OrderUpdater.class_eval do
+  unless self.method_defined?('update_adjustments_with_promotion_limiting')
+    def update_adjustments_with_promotion_limiting
+      update_adjustments_without_promotion_limiting
+      return if adjustments.promotion.eligible.none?
+      most_valuable_adjustment = adjustments.promotion.eligible.max{|a,b| a.amount.abs <=> b.amount.abs}
+      current_adjustments = (adjustments.promotion.eligible - [most_valuable_adjustment])
+      current_adjustments.each do |adjustment|
+        adjustment.update_attribute_without_callbacks(:eligible, false)
+      end
+    end
+    alias_method_chain :update_adjustments, :promotion_limiting
+  end
+end

data/app/models/spree/payment_decorator.rb

@@ -0,0 +1,5 @@
+Spree::Payment.class_eval do
+  def promo_total
+    order.promo_total * 100
+  end
+end

data/app/models/spree/product_decorator.rb

@@ -0,0 +1,8 @@
+Spree::Product.class_eval do
+  has_and_belongs_to_many :promotion_rules, :join_table => :spree_products_promotion_rules
+
+  def possible_promotions
+    promotion_ids = promotion_rules.map(&:activator_id).uniq
+    Spree::Promotion.advertised.where(:id => promotion_ids).reject(&:expired?)
+  end
+end

data/app/models/spree/promotion.rb

@@ -0,0 +1,105 @@
+module Spree
+  class Promotion < Spree::Activator
+    MATCH_POLICIES = %w(all any)
+    UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
+
+    Activator.event_names << 'spree.checkout.coupon_code_added'
+    Activator.event_names << 'spree.content.visited'
+
+    has_many :promotion_rules, :foreign_key => :activator_id, :autosave => true, :dependent => :destroy
+    alias_method :rules, :promotion_rules
+    accepts_nested_attributes_for :promotion_rules
+
+    has_many :promotion_actions, :foreign_key => :activator_id, :autosave => true, :dependent => :destroy
+    alias_method :actions, :promotion_actions
+    accepts_nested_attributes_for :promotion_actions
+
+    validates_associated :rules
+
+    attr_accessible :name, :event_name, :code, :match_policy,
+                    :path, :advertise, :description, :usage_limit,
+                    :starts_at, :expires_at, :promotion_rules_attributes,
+                    :promotion_actions_attributes
+
+    # TODO: This shouldn't be necessary with :autosave option but nested attribute updating of actions is broken without it
+    after_save :save_rules_and_actions
+    def save_rules_and_actions
+      (rules + actions).each &:save
+    end
+
+    validates :name, :presence => true
+    validates :code, :presence => true, :if => lambda{|r| r.event_name == 'spree.checkout.coupon_code_added' }
+    validates :path, :presence => true, :if => lambda{|r| r.event_name == 'spree.content.visited' }
+    validates :usage_limit, :numericality => { :greater_than => 0, :allow_nil => true }
+
+    def self.advertised
+      where(:advertise => true)
+    end
+
+    def activate(payload)
+      return unless order_activatable? payload[:order]
+
+      if code.present?
+        event_code = payload[:coupon_code]
+        return unless event_code == self.code
+      end
+
+      if path.present?
+        return unless path == payload[:path]
+      end
+
+      actions.each do |action|
+        action.perform(payload)
+      end
+    end
+
+    # called anytime order.update! happens
+    def eligible?(order)
+      return false if expired? || usage_limit_exceeded?(order)
+      rules_are_eligible?(order, {})
+    end
+
+    def rules_are_eligible?(order, options = {})
+      return true if rules.none?
+      eligible = lambda { |r| r.eligible?(order, options) }
+      if match_policy == 'all'
+        rules.all?(&eligible)
+      else
+        rules.any?(&eligible)
+      end
+    end
+
+    def order_activatable?(order)
+      order &&
+      created_at.to_i < order.created_at.to_i &&
+      !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    end
+
+    # Products assigned to all product rules
+    def products
+      @products ||= rules.of_type('Spree::Promotion::Rules::Product').map(&:products).flatten.uniq
+    end
+
+    def usage_limit_exceeded?(order = nil)
+      usage_limit.present? && usage_limit > 0 && adjusted_credits_count(order) >= usage_limit
+    end
+
+    def adjusted_credits_count(order)
+      return credits_count if order.nil?
+      credits_count - (order.promotion_credit_exists?(self) ? 1 : 0)
+    end
+
+    def credits
+      Adjustment.promotion.where(:originator_id => actions.map(&:id))
+    end
+
+    def credits_count
+      credits.count
+    end
+
+    def code=(coupon_code)
+      write_attribute(:code, (coupon_code.downcase.strip rescue nil))
+    end
+
+  end
+end

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

@@ -0,0 +1,48 @@
+module Spree
+  class Promotion
+    module Actions
+      class CreateAdjustment < PromotionAction
+        calculated_adjustments
+
+        delegate :eligible?, :to => :promotion
+
+        before_validation :ensure_action_has_calculator
+
+        def perform(options = {})
+          return unless order = options[:order]
+          # Nothing to do if the promotion is already associated with the order
+          return if order.promotion_credit_exists?(promotion)
+
+          order.adjustments.promotion.reload.clear
+          order.update!
+          create_adjustment("#{I18n.t(:promotion)} (#{promotion.name})", order, order)
+          order.update!
+        end
+
+        # override of CalculatedAdjustments#create_adjustment so promotional
+        # adjustments are added all the time. They will get their eligability
+        # set to false if the amount is 0
+        def create_adjustment(label, target, calculable, mandatory=false)
+          amount = compute_amount(calculable)
+          params = { :amount => amount,
+                    :source => calculable,
+                    :originator => self,
+                    :label => label,
+                    :mandatory => mandatory }
+          target.adjustments.create(params, :without_protection => true)
+        end
+
+        # Ensure a negative amount which does not exceed the sum of the order's item_total and ship_total
+        def compute_amount(calculable)
+          [(calculable.item_total + calculable.ship_total), super.to_f.abs].min * -1
+        end
+
+        private
+        def ensure_action_has_calculator
+          return if self.calculator
+          self.calculator = Calculator::FlatPercentItemTotal.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Spree
+  class Promotion
+    module Actions
+      class CreateLineItems < PromotionAction
+        has_many :promotion_action_line_items, :foreign_key => :promotion_action_id
+        accepts_nested_attributes_for :promotion_action_line_items
+        attr_accessible :promotion_action_line_items_attributes
+
+
+        def perform(options = {})
+          return unless order = options[:order]
+          promotion_action_line_items.each do |item|
+            current_quantity = order.quantity_of(item.variant)
+            if current_quantity < item.quantity
+              order.add_variant(item.variant, item.quantity - current_quantity)
+              order.update!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Spree
+  class Promotion
+    module Rules
+      class FirstOrder < PromotionRule
+        def eligible?(order, options = {})
+          user = order.try(:user) || options[:user]
+          !!(user && user.orders.complete.count == 0)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# A rule to apply to an order greater than (or greater than or equal to)
+# a specific amount
+module Spree
+  class Promotion
+    module Rules
+      class ItemTotal < PromotionRule
+        preference :amount, :decimal, :default => 100.00
+        preference :operator, :string, :default => '>'
+
+        attr_accessible :preferred_amount, :preferred_operator
+
+        OPERATORS = ['gt', 'gte']
+
+        def eligible?(order, options = {})
+          item_total = order.line_items.map(&:amount).sum
+          item_total.send(preferred_operator == 'gte' ? :>= : :>, BigDecimal.new(preferred_amount.to_s))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# A rule 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 rule.
+module Spree
+  class Promotion
+    module Rules
+      class Product < PromotionRule
+        has_and_belongs_to_many :products, :class_name => '::Spree::Product', :join_table => 'spree_products_promotion_rules', :foreign_key => 'promotion_rule_id'
+        validate :only_one_promotion_per_product
+
+        MATCH_POLICIES = %w(any all)
+        preference :match_policy, :string, :default => MATCH_POLICIES.first
+
+        # scope/association that is used to test eligibility
+        def eligible_products
+          products
+        end
+
+        def eligible?(order, options = {})
+          return true if eligible_products.empty?
+          if preferred_match_policy == 'all'
+            eligible_products.all? {|p| order.products.include?(p) }
+          else
+            order.products.any? {|p| eligible_products.include?(p) }
+          end
+        end
+
+        def product_ids_string
+          product_ids.join(',')
+        end
+
+        def product_ids_string=(s)
+          self.product_ids = s.to_s.split(',').map(&:strip)
+        end
+
+        private
+
+          def only_one_promotion_per_product
+            if Spree::Promotion::Rules::Product.all.map(&:products).flatten.uniq!
+              errors[:base] << "You can't create two promotions for the same product"
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Spree
+  class Promotion
+    module Rules
+      class User < PromotionRule
+        attr_accessible :user_ids_string
+
+        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'
+
+        def eligible?(order, options = {})
+          users.none? or users.include?(order.user)
+        end
+
+        def user_ids_string
+          user_ids.join(',')
+        end
+
+        def user_ids_string=(s)
+          self.user_ids = s.to_s.split(',').map(&:strip)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Spree
+  class Promotion
+    module Rules
+      class UserLoggedIn < PromotionRule
+
+        def eligible?(order, options = {})
+          # this is tricky.  We couldn't use any of the devise methods since we aren't in the controller.
+          # we need to rely on the controller already having done this for us.
+
+          # The thinking is that the controller should have some sense of what state
+          # we should be in before firing events,
+          # so the controller will have to set this field.
+
+          return options && options[:user_signed_in]
+        end
+
+      end
+    end
+  end
+end

data/app/models/spree/promotion_action.rb

@@ -0,0 +1,19 @@
+# Base class for all types of promotion action.
+# 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"
+
+    scope :of_type, lambda {|t| {:conditions => {:type => t}}}
+
+    attr_accessible :line_items_string
+
+    # This method should be overriden in subclass
+    # Updates the state of the order or performs some other action depending on the subclass
+    # options will contain the payload from the event that activated the promotion. This will include
+    # the key :user which allows user based actions to be performed in addition to actions on the order
+    def perform(options = {})
+      raise 'perform should be implemented in a sub-class of PromotionAction'
+    end
+  end
+end

data/app/models/spree/promotion_action_line_item.rb

@@ -0,0 +1,8 @@
+module Spree
+  class PromotionActionLineItem < ActiveRecord::Base
+    belongs_to :promotion_action, :class_name => 'Spree::Promotion::Actions::CreateLineItems'
+    belongs_to :variant, :class_name => "Spree::Variant"
+
+    attr_accessible :quantity, :variant_id
+  end
+end

data/app/models/spree/promotion_rule.rb

@@ -0,0 +1,25 @@
+# Base class for all promotion rules
+module Spree
+  class PromotionRule < ActiveRecord::Base
+    belongs_to :promotion, :foreign_key => 'activator_id', :class_name => "Spree::Promotion"
+
+    scope :of_type, lambda {|t| {:conditions => {:type => t}}}
+
+    validate :promotion, :presence => true
+    validate :unique_per_activator, :on => :create
+
+    attr_accessible :preferred_operator, :preferred_amount, :product, :product_ids_string, :preferred_match_policy
+
+    def eligible?(order, options = {})
+      raise 'eligible? should be implemented in a sub-class of Promotion::PromotionRule'
+    end
+
+    private
+    def unique_per_activator
+      if Spree::PromotionRule.exists?(:activator_id => activator_id, :type => self.class.name)
+        errors[:base] << "Promotion already contains this rule type"
+      end
+    end
+ 
+  end
+end