spree_promo 1.1.1 → 1.1.2.rc1

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

@@ -40,19 +40,15 @@ var initProductActions = function(){
 
     // Remove line item
     var setupRemoveLineItems = function(){
-      $(".promotion_action.create_line_items table img").unbind('click').click(function(){
-        var $container = $(this).parents('.promotion_action');
-        var $hiddenField = $container.find("input[type='hidden']");
-        var $row = $(this).parents('tr');
-        var index = $row.parents('table').find('tr').index($row.get(0));
-        // Remove variant_id quantity pair from the string
-        var items = _($hiddenField.val().split(',')).compact();
-        items.splice(index - 1, 1);
-        $hiddenField.val(items.join(','));
+      $(".remove_promotion_line_item").click(function(){
+        line_items_el = $($('.line_items_string')[0])
+        finder = RegExp($(this).data("variant-id") + "x\\d+")
+        line_items_el.val(line_items_el.val().replace(finder, ""))
         $(this).parents('tr').remove();
         hideOrShowItemTables();
       });
     };
+
     setupRemoveLineItems();
     // Add line item to list
     $(".promotion_action.create_line_items button.add").unbind('click').click(function(e){

data/app/models/spree/order_decorator.rb

@@ -18,7 +18,12 @@ Spree::Order.class_eval do
       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}
-      ( adjustments.promotion.eligible - [most_valuable_adjustment] ).each{|adjustment| adjustment.update_attribute_without_callbacks(:eligible, false)}
+      current_adjustments = (adjustments.promotion.eligible - [most_valuable_adjustment])
+      current_adjustments.each do |adjustment|
+        if adjustment.originator.calculator.is_a?(Spree::Calculator::PerItem)
+          adjustment.update_attribute_without_callbacks(:eligible, false)
+        end
+      end
     end
     alias_method_chain :update_adjustments, :promotion_limiting
   end

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

@@ -1,43 +1,48 @@
 module Spree
-  class Promotion::Actions::CreateAdjustment < PromotionAction
-    calculated_adjustments
+  class Promotion
+    module Actions
+      class CreateAdjustment < PromotionAction
+        calculated_adjustments
 
-    delegate :eligible?, :to => :promotion
+        delegate :eligible?, :to => :promotion
 
-    before_validation :ensure_action_has_calculator
+        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)
+        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)
-    end
+          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
+        # 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
+        # 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
+        private
+        def ensure_action_has_calculator
+          return if self.calculator
+          self.calculator = Calculator::FlatPercentItemTotal.new
+        end
+      end
     end
   end
-end
+end

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

@@ -1,31 +1,36 @@
 module Spree
-  class Promotion::Actions::CreateLineItems < PromotionAction
-    has_many :promotion_action_line_items, :foreign_key => 'promotion_action_id'
+  class Promotion
+    module Actions
+      class CreateLineItems < PromotionAction
+        has_many :promotion_action_line_items, :foreign_key => 'promotion_action_id'
 
-    attr_accessor :line_items_string
+        attr_accessor :line_items_string
 
-    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)
+        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
 
-    def line_items_string
-      promotion_action_line_items.map { |li| "#{li.variant_id}x#{li.quantity}" }.join(',')
-    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}, :without_protection => true)
+        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}, :without_protection => true)
+            end
+          end
         end
       end
     end
   end
-end
+end

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

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

@@ -1,16 +1,20 @@
 # 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 => '>'
+  class Promotion
+    module Rules
+      class ItemTotal < PromotionRule
+        preference :amount, :decimal, :default => 100.00
+        preference :operator, :string, :default => '>'
 
-    attr_accessible :preferred_amount, :preferred_operator
+        attr_accessible :preferred_amount, :preferred_operator
 
-    OPERATORS = ['gt', 'gte']
+        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))
+        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

@@ -2,32 +2,45 @@
 # 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
-    has_and_belongs_to_many :products, :class_name => '::Spree::Product', :join_table => 'spree_products_promotion_rules', :foreign_key => 'promotion_rule_id'
+  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
+        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
+        # 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 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
+          product_ids.join(',')
+        end
 
-    def product_ids_string=(s)
-      self.product_ids = s.to_s.split(',').map(&:strip)
+        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

@@ -1,18 +1,24 @@
 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'
+  class Promotion
+    module Rules
+      class User < PromotionRule
+        attr_accessible :user_ids_string
 
-    def eligible?(order, options = {})
-      users.none? or users.include?(order.user)
-    end
+        belongs_to :user, :class_name => "Spree::User"
+        has_and_belongs_to_many :users, :class_name => '::Spree::User', :join_table => 'spree_promotion_rules_users', :foreign_key => 'promotion_rule_id'
 
-    def user_ids_string
-      user_ids.join(',')
-    end
+        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)
+        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

@@ -1,15 +1,20 @@
 module Spree
-  class Promotion::Rules::UserLoggedIn < PromotionRule
-    def eligible?(order, options = {})
+  class Promotion
+    module Rules
+      class UserLoggedIn < PromotionRule
 
-      # 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.
+        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.
+          # 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]
+          return options && options[:user_signed_in]
+        end
+
+      end
     end
   end
 end

data/app/models/spree/promotion.rb

@@ -14,6 +14,8 @@ module Spree
     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,

data/app/models/spree/promotion_action.rb

@@ -2,10 +2,12 @@
 # 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'
+    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

data/app/models/spree/promotion_action_line_item.rb

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

data/app/models/spree/promotion_rule.rb

@@ -1,7 +1,7 @@
 # Base class for all promotion rules
 module Spree
   class PromotionRule < ActiveRecord::Base
-    belongs_to :promotion, :foreign_key => 'activator_id'
+    belongs_to :promotion, :foreign_key => 'activator_id', :class_name => "Spree::Promotion"
 
     scope :of_type, lambda {|t| {:conditions => {:type => t}}}
 

data/app/views/spree/admin/promotions/actions/_create_line_items.html.erb

@@ -13,7 +13,7 @@
         <%= item.quantity %>
       </td>
       <td>
-        <%= image_tag 'admin/icons/cross.png' %>
+        <%= image_tag 'admin/icons/cross.png', :class => "remove_promotion_line_item", :data => { :variant_id => item.variant_id } %>
       </td>
     </tr>
   <% end %>

metadata

@@ -1,38 +1,38 @@
 --- !ruby/object:Gem::Specification
 name: spree_promo
 version: !ruby/object:Gem::Version
-  version: 1.1.1
-  prerelease: 
+  version: 1.1.2.rc1
+  prerelease: 6
 platform: ruby
 authors:
 - David North
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-16 00:00:00.000000000 Z
+date: 2012-06-25 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree_core
-  requirement: &70340061938220 !ruby/object:Gem::Requirement
+  requirement: &70249530014760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.1.2.rc1
   type: :runtime
   prerelease: false
-  version_requirements: *70340061938220
+  version_requirements: *70249530014760
 - !ruby/object:Gem::Dependency
   name: spree_auth
-  requirement: &70340061937140 !ruby/object:Gem::Requirement
+  requirement: &70249530003060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.1.2.rc1
   type: :runtime
   prerelease: false
-  version_requirements: *70340061937140
+  version_requirements: *70249530003060
 description: Required dependency for Spree
 email: david@spreecommerce.com
 executables: []
@@ -127,12 +127,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -2121439115021991443
+      version: 1.3.1
 requirements:
 - none
 rubyforge_project: