spree_promo 0.70.7 → 1.0.0.rc1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007-2011, Rails Dog LLC and other contributors
+Copyright (c) 2007-2011, Spree Commerce, Inc. and other contributors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,
@@ -23,4 +23,4 @@ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/app/assets/javascripts/admin/promotions.js

@@ -3,7 +3,7 @@ var initProductRuleSourceField = function(){
 
   $products_source_field = jQuery('.products_rule_products_source_field input');
   $products_source_field.click(function() {
-    $rule_container = jQuery(this).parents('.promotion_rule');
+    $rule_container = jQuery(this).parents('.promotion-rule');
     if(this.checked){
       if(this.value == 'manual'){
         $rule_container.find('.products_rule_products').show();
@@ -48,26 +48,6 @@ var initProductActions = function(){
   // CreateLineItems Promotion Action
   //
   ( function(){
-    // Autocomplete product and populate variant select
-    if($('.promotion_action.create_line_items ').is('*')){
-      $(".promotion_action.create_line_items input[name='add_product_name']").autocomplete("/admin/products.json?authenticity_token=" + $('meta[name=csrf-token]').attr("content"), {
-        parse: prep_product_autocomplete_data,
-        formatItem: function(item) {
-          return format_product_autocomplete(item);
-        }
-      }).result(function(event, data, formatted) {
-        if(data){
-          if(data['variant']==undefined){
-            // product
-            $('#add_line_item_variant_id').val(data['product']['master']['id']);
-          }else{
-            // variant
-            $('#add_line_item_variant_id').val(data['variant']['id']);
-          }
-        }
-      });
-    }
-
     var hideOrShowItemTables = function(){
       $('.promotion_action table').each(function(){
         if($(this).find('td').length == 0){
@@ -96,10 +76,10 @@ var initProductActions = function(){
     };
     setupRemoveLineItems();
     // Add line item to list
-    $(".promotion_action.create_line_items button.add").live('click',function(){
+    $(".promotion_action.create_line_items button.add").live('click',function(e){
       var $container = $(this).parents('.promotion_action');
       var product_name = $container.find("input[name='add_product_name']").val();
-      var variant_id = $container.find("input[name='add_line_item_variant_id']").val();
+      var variant_id = $container.find("input[name='add_variant_id']").val();
       var quantity = $container.find("input[name='add_quantity']").val();
       if(variant_id){
         // Add to the table

data/app/controllers/spree/admin/promotion_actions_controller.rb

@@ -0,0 +1,27 @@
+class Spree::Admin::PromotionActionsController < Spree::Admin::BaseController
+  def create
+    @calculators = Spree::Promotion::Actions::CreateAdjustment.calculators
+    @promotion = Spree::Promotion.find(params[:promotion_id])
+    @promotion_action = params[:action_type].constantize.new(params[:promotion_action])
+    @promotion_action.promotion = @promotion
+    if @promotion_action.save
+      flash.notice = I18n.t(:successfully_created, :resource => I18n.t(:promotion_action))
+    end
+    respond_to do |format|
+      format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+      format.js   { render :layout => false }
+    end
+  end
+
+  def destroy
+    @promotion = Spree::Promotion.find(params[:promotion_id])
+    @promotion_action = @promotion.promotion_actions.find(params[:id])
+    if @promotion_action.destroy
+      flash.notice = I18n.t(:successfully_removed, :resource => I18n.t(:promotion_action))
+    end
+    respond_to do |format|
+      format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+      format.js   { render :layout => false }
+    end
+  end
+end

data/app/controllers/spree/admin/promotion_rules_controller.rb

@@ -0,0 +1,26 @@
+class Spree::Admin::PromotionRulesController < Spree::Admin::BaseController
+  def create
+    @promotion = Spree::Promotion.find(params[:promotion_id])
+    @promotion_rule = params[:promotion_rule][:type].constantize.new(params[:promotion_rule])
+    @promotion_rule.promotion = @promotion
+    if @promotion_rule.save
+      flash.notice = I18n.t(:successfully_created, :resource => I18n.t(:promotion_rule))
+    end
+    respond_to do |format|
+      format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+      format.js   { render :layout => false }
+    end
+  end
+
+  def destroy
+    @promotion = Spree::Promotion.find(params[:promotion_id])
+    @promotion_rule = @promotion.promotion_rules.find(params[:id])
+    if @promotion_rule.destroy
+      flash.notice = I18n.t(:successfully_removed, :resource => I18n.t(:promotion_rule))
+    end
+    respond_to do |format|
+      format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+      format.js   { render :layout => false }
+    end
+  end
+end

data/app/controllers/spree/admin/promotions_controller.rb

@@ -0,0 +1,24 @@
+module Spree
+  module Admin
+    class PromotionsController < ResourceController
+      before_filter :load_data
+
+      protected
+        def build_resource
+          @promotion = Promotion.new(params[:promotion])
+          if params[:promotion] && params[:promotion][:calculator_type]
+            @promotion.calculator = params[:promotion][:calculator_type].constantize.new
+          end
+          @promotion
+        end
+
+        def location_after_save
+          spree.edit_admin_promotion_url(@promotion)
+        end
+
+        def load_data
+          @calculators = Rails.application.config.spree.calculators.promotion_actions_create_adjustments
+        end
+    end
+  end
+end

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -0,0 +1,39 @@
+Spree::CheckoutController.class_eval do
+  def update
+    if @order.update_attributes(object_params)
+
+      fire_event('spree.checkout.update')
+
+      if @order.coupon_code.present?
+        # Promotion codes are stored in the preference table
+        # Therefore we need to do a lookup there and find if one exists
+        if Spree::Preference.where(:value => @order.coupon_code).where("key LIKE 'spree/promotion/code/%'").present?
+          fire_event('spree.checkout.coupon_code_added', :coupon_code => @order.coupon_code)
+        # If it doesn't exist, raise an error!
+        # Giving them another chance to enter a valid coupon code
+        else
+          flash[:error] = t(:promotion_not_found)
+          render :edit and return
+        end
+      end
+
+      if @order.next
+        state_callback(:after)
+      else
+        flash[:error] = t(:payment_processing_failed)
+        respond_with(@order, :location => checkout_state_path(@order.state))
+        return
+      end
+
+      if @order.state == 'complete' || @order.completed?
+        flash.notice = t(:order_processed_successfully)
+        flash[:commerce_tracking] = 'nothing special'
+        respond_with(@order, :location => completion_route)
+      else
+        respond_with(@order, :location => checkout_state_path(@order.state))
+      end
+    else
+      respond_with(@order) { |format| format.html { render :edit } }
+    end
+  end
+end

data/app/controllers/{content_controller_decorator.rb → spree/content_controller_decorator.rb}

@@ -1,8 +1,10 @@
 # Keep a record ot all static page paths visited for promotions that require them
-ContentController.class_eval do
+Spree::ContentController.class_eval do
   after_filter :store_visited_path
+
   def store_visited_path
     session[:visited_paths] ||= []
-    session[:visited_paths] = (session[:visited_paths]  + [params[:path]]).compact.uniq
+    path = "content/#{params[:action]}"
+    session[:visited_paths] = (session[:visited_paths]  << path).compact.uniq
   end
 end

data/app/controllers/{orders_controller_decorator.rb → spree/orders_controller_decorator.rb}

@@ -1,5 +1,4 @@
-OrdersController.class_eval do
-
+Spree::OrdersController.class_eval do
   def update
     @order = current_order
     if @order.update_attributes(params[:order])
@@ -15,5 +14,4 @@ OrdersController.class_eval do
       respond_with(@order)
     end
   end
-
 end

data/app/models/{adjustment_decorator.rb → spree/adjustment_decorator.rb}

@@ -1,3 +1,3 @@
-Adjustment.class_eval do
+Spree::Adjustment.class_eval do
   scope :promotion, lambda { where('label LIKE ?', "#{I18n.t(:promotion)}%") }
 end

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

@@ -0,0 +1,18 @@
+module Spree
+  class Calculator::FreeShipping < Calculator
+    def self.description
+      I18n.t(:free_shipping)
+    end
+
+    def compute(object)
+      if object.is_a?(Array)
+        return if object.empty?
+        order = object.first.order
+      else
+        order = object
+      end
+
+      order.ship_total
+    end
+  end
+end

data/app/models/{order_decorator.rb → spree/order_decorator.rb}

@@ -1,8 +1,10 @@
-Order.class_eval do
-
+Spree::Order.class_eval do
   attr_accessible :coupon_code
   attr_accessor :coupon_code
 
+  # 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
@@ -11,7 +13,7 @@ Order.class_eval do
     line_items.map {|li| li.variant.product}
   end
 
-  unless self.instance_methods.include?("update_adjustments_with_promotion_limiting")
+  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?
@@ -20,5 +22,4 @@ Order.class_eval do
     end
     alias_method_chain :update_adjustments, :promotion_limiting
   end
-
 end

data/app/models/{product_decorator.rb → spree/product_decorator.rb}

@@ -1,10 +1,10 @@
-Product.class_eval do
-  has_and_belongs_to_many :promotion_rules
+Spree::Product.class_eval do
+  has_and_belongs_to_many :promotion_rules, :join_table => 'spree_products_promotion_rules'
 
   def possible_promotions
     rules_with_matching_product_groups = product_groups.map(&:promotion_rules).flatten
     all_rules = promotion_rules + rules_with_matching_product_groups
     promotion_ids = all_rules.map(&:activator_id).uniq
-    Promotion.advertised.where(:id => promotion_ids)
+    Spree::Promotion.advertised.where(:id => promotion_ids)
   end
 end

data/app/models/spree/product_group_decorator.rb

@@ -0,0 +1,3 @@
+Spree::ProductGroup.class_eval do
+  has_many :promotion_rules
+end

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

@@ -0,0 +1,33 @@
+module Spree
+  class Promotion::Actions::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)
+      if amount = calculator.compute(order)
+        amount = BigDecimal.new(amount.to_s)
+        amount = order.item_total if amount > order.item_total
+        order.adjustments.promotion.reload.clear
+        order.update!
+        create_adjustment("#{I18n.t(:promotion)} (#{promotion.name})", order, order)
+      end
+    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

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

@@ -0,0 +1,28 @@
+module Spree
+  class Promotion::Actions::CreateLineItems < PromotionAction
+    has_many :promotion_action_line_items, :foreign_key => 'promotion_action_id'
+
+    attr_accessor :line_items_string
+
+    def perform(options = {})
+      return unless order = options[:order]
+      promotion_action_line_items.each do |item|
+        order.add_variant(item.variant, item.quantity)
+      end
+    end
+
+    def line_items_string
+      promotion_action_line_items.map { |li| "#{li.variant_id}x#{li.quantity}" }.join(',')
+    end
+
+    def line_items_string=(value)
+      promotion_action_line_items.destroy_all
+      value.to_s.split(',').each do |str|
+        variant_id, quantity = str.split('x')
+        if variant_id && quantity && variant = Variant.find_by_id(variant_id)
+          promotion_action_line_items.create(:variant => variant, :quantity => quantity.to_i)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,14 @@
+# A rule to limit a promotion to a specific user.
+module Spree
+  class Promotion::Rules::ItemTotal < PromotionRule
+    preference :amount, :decimal, :default => 100.00
+    preference :operator, :string, :default => '>'
+
+    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

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

@@ -0,0 +1,16 @@
+# A rule to limit a promotion to a specific user.
+module Spree
+  class Promotion::Rules::LandingPage < PromotionRule
+    preference :path, :string
+
+    def eligible?(order, options = {})
+      if options.has_key?(:visited_paths)
+        options[:visited_paths].to_a.any? do |path|
+          path == preferred_path
+        end
+      else
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# 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::Rules::Product < PromotionRule
+    belongs_to :product_group
+    has_and_belongs_to_many :products, :class_name => '::Spree::Product', :join_table => 'spree_products_promotion_rules', :foreign_key => 'promotion_rule_id'
+
+    MATCH_POLICIES = %w(any all)
+    preference :match_policy, :string, :default => MATCH_POLICIES.first
+
+    # scope/association that is used to test eligibility
+    def eligible_products
+      product_group ? product_group.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 products_source=(source)
+      if source.to_s == 'manual'
+        self.product_group_id = nil
+      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
+  end
+end

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

@@ -0,0 +1,18 @@
+module Spree
+  class Promotion::Rules::User < PromotionRule
+    belongs_to :user
+    has_and_belongs_to_many :users, :class_name => '::Spree::User', :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

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

@@ -0,0 +1,15 @@
+module Spree
+  class Promotion::Rules::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

data/app/models/spree/promotion.rb

@@ -0,0 +1,131 @@
+module Spree
+  class Promotion < Spree::Activator
+    MATCH_POLICIES = %w(all any)
+
+    preference :usage_limit, :integer
+    preference :match_policy, :string, :default => MATCH_POLICIES.first
+    preference :code, :string
+    preference :advertise, :boolean, :default => false
+
+    [:usage_limit, :match_policy, :code, :advertise].each do |field|
+      alias_method field, "preferred_#{field}"
+      alias_method "#{field}=", "preferred_#{field}="
+    end
+
+    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
+
+    after_create :update_preferences
+
+    # 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 :preferred_code, :presence => true, :if => lambda{|r| r.event_name == 'spree.checkout.coupon_code_added' }
+
+    %w(usage_limit match_policy code advertise).each do |pref|
+      method_name = pref.to_sym
+      define_method method_name do
+        get_preference(pref.to_sym)
+      end
+
+      method_name = "#{pref}=".to_sym
+      define_method method_name do |value|
+        unless new_record?
+          pref = value
+        else
+          @preferences_hash ||= {}
+          @preferences_hash[pref.to_sym] = value
+        end
+      end
+    end
+
+    class << self
+      def advertised
+        #TODO this is broken because the new preferences aren't a direct relationship returning
+        #all for now
+        where(true)
+        #includes(:stored_preferences)
+        #includes(:stored_preferences).where(:spree_preferences => {:name => 'advertise', :value => '1'})
+      end
+    end
+
+    # TODO: Remove that after fix for https://rails.lighthouseapp.com/projects/8994/tickets/4329-has_many-through-association-does-not-link-models-on-association-save
+    # is provided
+    def save(*)
+      if super
+        promotion_rules.each { |p| p.save }
+      end
+    end
+
+    def activate(payload)
+      # Since multiple promotions could be listening we need to make sure the
+      # event applies to this one.
+      if eligible?(payload[:order], payload)
+        actions.each do |action|
+          action.perform(payload)
+        end
+      end
+    end
+
+    # Whether the promotion is eligible for this particular order.
+    def eligible?(order, options = {})
+      return false if expired? || usage_limit_exceeded?(order)
+      if event_code = options[:coupon_code].to_s.strip.downcase
+        return false unless event_code == self.code.to_s.strip.downcase
+      end
+      rules_are_eligible?(order, options)
+    end
+
+    def rules_are_eligible?(order, options = {})
+      return true if rules.none?
+      if match_policy == 'all'
+        rules.all?{|r| r.eligible?(order, options)}
+      else
+        rules.any?{|r| r.eligible?(order, options)}
+      end
+    end
+
+    # Products assigned to all product rules
+    def products
+      @products ||= rules.of_type('Promotion::Rules::Product').map(&:products).flatten.uniq
+    end
+
+    def usage_limit_exceeded?(order = nil)
+      preferred_usage_limit.present? && preferred_usage_limit.to_i > 0 && adjusted_credits_count(order) >= preferred_usage_limit.to_i
+    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
+
+
+    private
+
+    def update_preferences
+      if @preferences_hash.present? && !@preferences_hash.empty?
+        @preferences_hash.each do |key, value|
+          pref_key = "spree/promotion/#{key}/#{self.id}"
+          Spree::Preference.create(:value => value, :key => pref_key)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/promotion_action.rb

@@ -0,0 +1,17 @@
+# 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'
+
+    scope :of_type, lambda {|t| {:conditions => {:type => t}}}
+
+    # 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,6 @@
+module Spree
+  class PromotionActionLineItem < ActiveRecord::Base
+    belongs_to :promotion_action, :class_name => 'Spree::Promotion::Actions::CreateLineItems'
+    belongs_to :variant
+  end
+end

data/app/models/spree/promotion_rule.rb

@@ -0,0 +1,12 @@
+# Base class for all promotion rules
+module Spree
+  class PromotionRule < ActiveRecord::Base
+    belongs_to :promotion, :foreign_key => 'activator_id'
+
+    scope :of_type, lambda {|t| {:conditions => {:type => t}}}
+
+    def eligible?(order, options = {})
+      raise 'eligible? should be implemented in a sub-class of Promotion::PromotionRule'
+    end
+  end
+end

data/app/overrides/promo_admin_tabs.rb

@@ -1,5 +1,5 @@
-Deface::Override.new(:virtual_path => "layouts/admin",
+Deface::Override.new(:virtual_path => "spree/layouts/admin",
                      :name => "promo_admin_tabs",
                      :insert_bottom => "[data-hook='admin_tabs'], #admin_tabs[data-hook]",
-                     :text => "<%= tab(:promotions) %>",
+                     :text => "<%= tab(:promotions, :url => spree.admin_promotions_path) %>",
                      :disabled => false)

data/app/overrides/promo_coupon_code_field.rb

@@ -1,5 +1,5 @@
-Deface::Override.new(:virtual_path => "checkout/_payment",
+Deface::Override.new(:virtual_path => "spree/checkout/_payment",
                      :name => "promo_coupon_code_field",
                      :replace => "[data-hook='coupon_code_field'], #coupon_code_field[data-hook]",
-                     :partial => "checkout/coupon_code_field",
+                     :partial => "spree/checkout/coupon_code_field",
                      :disabled => false)

data/app/overrides/promo_product_properties.rb

@@ -1,5 +1,5 @@
-Deface::Override.new(:virtual_path => "products/show",
+Deface::Override.new(:virtual_path => "spree/products/show",
                      :name => "promo_product_properties",
                      :insert_after => "[data-hook='product_properties'], #product_properties[data-hook]",
-                     :partial => "products/promotions",
+                     :partial => "spree/products/promotions",
                      :disabled => false)