spree_core 1.3.5 → 2.0.0.rc1

data/app/models/spree/product.rb

@@ -17,72 +17,71 @@
 # All other variants have option values and may have inventory units.
 # Sum of on_hand each variant's inventory level determine "on_hand" level for the product.
 #
+
 module Spree
   class Product < ActiveRecord::Base
-    has_many :product_option_types, :dependent => :destroy
-    has_many :option_types, :through => :product_option_types
-    has_many :product_properties, :dependent => :destroy
-    has_many :properties, :through => :product_properties
+    has_many :product_option_types, dependent: :destroy
+    has_many :option_types, through: :product_option_types
+    has_many :product_properties, dependent: :destroy
+    has_many :properties, through: :product_properties
 
-    has_many :classifications, :dependent => :delete_all
-    has_many :taxons, :through => :classifications
+    has_many :classifications, dependent: :delete_all
+    has_many :taxons, through: :classifications
+    has_and_belongs_to_many :promotion_rules, join_table: :spree_products_promotion_rules
 
-    belongs_to :tax_category
-    belongs_to :shipping_category
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory'
 
     has_one :master,
-      :class_name => 'Spree::Variant',
-      :conditions => { :is_master => true },
-      :dependent => :destroy
+      class_name: 'Spree::Variant',
+      conditions: { is_master: true },
+      dependent: :destroy
 
     has_many :variants,
-      :class_name => 'Spree::Variant',
-      :conditions => { :is_master => false, :deleted_at => nil },
-      :order => "#{::Spree::Variant.quoted_table_name}.position ASC"
+      class_name: 'Spree::Variant',
+      conditions: { is_master: false, deleted_at: nil },
+      order: "#{::Spree::Variant.quoted_table_name}.position ASC"
 
     has_many :variants_including_master,
-      :class_name => 'Spree::Variant',
-      :conditions => { :deleted_at => nil },
-      :dependent => :destroy
+      class_name: 'Spree::Variant',
+      conditions: { deleted_at: nil },
+      dependent: :destroy
 
-    has_many :variants_including_master_and_deleted, :class_name => 'Spree::Variant'
+    has_many :variants_including_master_and_deleted, class_name: 'Spree::Variant'
 
-    has_many :prices, :through => :variants, :order => 'spree_variants.position, spree_variants.id, currency'
+    has_many :prices, through: :variants, order: 'spree_variants.position, spree_variants.id, currency'
 
     delegate_belongs_to :master, :sku, :price, :currency, :display_amount, :display_price, :weight, :height, :width, :depth, :is_master, :has_default_price?, :cost_currency, :price_in, :amount_in
     delegate_belongs_to :master, :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
 
     after_create :set_master_variant_defaults
     after_create :add_properties_and_option_types_from_prototype
-    after_create :build_variants_from_option_values_hash, :if => :option_values_hash
-    before_save :recalculate_count_on_hand
-
+    after_create :build_variants_from_option_values_hash, if: :option_values_hash
     after_save :save_master
-    after_save :set_master_on_hand_to_zero_when_product_has_variants
 
-    delegate :images, :to => :master, :prefix => true
+    delegate :images, to: :master, prefix: true
     alias_method :images, :master_images
 
-    has_many :variant_images, :source => :images, :through => :variants_including_master, :order => :position
+    has_many :variant_images, source: :images, through: :variants_including_master, order: :position
 
-    accepts_nested_attributes_for :variants, :allow_destroy => true
+    accepts_nested_attributes_for :variants, allow_destroy: true
 
-    validates :name, :permalink, :presence => true
-    validates :price, :presence => true, :if => proc { Spree::Config[:require_master_price] }
+    validates :name, :permalink, presence: true
+    validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
 
     attr_accessor :option_values_hash
 
     attr_accessible :name, :description, :available_on, :permalink, :meta_description,
                     :meta_keywords, :price, :sku, :deleted_at, :prototype_id,
-                    :option_values_hash, :on_demand, :on_hand, :weight, :height, :width, :depth,
+                    :option_values_hash, :weight, :height, :width, :depth,
                     :shipping_category_id, :tax_category_id, :product_properties_attributes,
                     :variants_attributes, :taxon_ids, :option_type_ids, :cost_currency
 
     attr_accessible :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
 
-    accepts_nested_attributes_for :product_properties, :allow_destroy => true, :reject_if => lambda { |pp| pp[:property_name].blank? }
+    accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp| pp[:property_name].blank? }
 
-    make_permalink :order => :name
+    make_permalink order: :name
 
     alias :options :product_option_types
 
@@ -97,53 +96,14 @@ module Spree
       permalink.present? ? permalink : (permalink_was || name.to_s.to_url)
     end
 
-    # returns true if the product has any variants (the master variant is not a member of the variants array)
+    # the master variant is not a member of the variants array
     def has_variants?
       variants.any?
     end
 
-    # should product be displayed on products pages and search
-    def on_display?
-      has_stock? || Spree::Config[:show_zero_stock_products]
-    end
-
-    # is this product actually available for purchase
-    def on_sale?
-      has_stock? || Spree::Config[:allow_backorders]
-    end
-
-    # returns the number of inventory units "on_hand" for this product
-    def on_hand
-      has_variants? ? variants.sum(&:on_hand) : master.on_hand
-    end
-
-    # adjusts the "on_hand" inventory level for the product up or down to match the given new_level
-    def on_hand=(new_level)
-      unless self.on_demand
-        raise 'cannot set on_hand of product with variants' if has_variants? && Spree::Config[:track_inventory_levels] 
-        master.on_hand = new_level
-      end
-    end
-
-    def on_demand=(new_on_demand)
-      raise 'cannot set on_demand of product with variants' if has_variants? && Spree::Config[:track_inventory_levels]
-      master.on_demand = new_on_demand
-      self[:on_demand] = new_on_demand
-    end
-
-    def count_on_hand=(value)
-      raise I18n.t('exceptions.count_on_hand_setter')
-    end
-
-    # Returns true if there are inventory units (any variant) with "on_hand" state for this product
-    # Variants take precedence over master
-    def has_stock?
-      has_variants? ? variants.any?(&:in_stock?) : master.in_stock?
-    end
-
     def tax_category
       if self[:tax_category_id].nil?
-        TaxCategory.where(:is_default => true).first
+        TaxCategory.where(is_default: true).first
       else
         TaxCategory.find(self[:tax_category_id])
       end
@@ -153,7 +113,7 @@ module Spree
     # instead of actually deleting the product.
     def delete
       self.update_column(:deleted_at, Time.now)
-      variants_including_master.update_all(:deleted_at => Time.now)
+      variants_including_master.update_all(deleted_at: Time.now)
     end
 
     # Adding properties and option types on creation based on a chosen prototype
@@ -167,38 +127,15 @@ module Spree
       return if option_values_hash.nil?
       option_values_hash.keys.map(&:to_i).each do |id|
         self.option_type_ids << id unless option_type_ids.include?(id)
-        product_option_types.create({:option_type_id => id}, :without_protection => true) unless product_option_types.pluck(:option_type_id).include?(id)
+        product_option_types.create({option_type_id: id}, without_protection: true) unless product_option_types.pluck(:option_type_id).include?(id)
       end
     end
 
     # for adding products which are closely related to existing ones
     # define "duplicate_extra" for site-specific actions, eg for additional fields
     def duplicate
-      p = self.dup
-      p.name = 'COPY OF ' + name
-      p.deleted_at = nil
-      p.created_at = p.updated_at = nil
-      p.taxons = taxons
-
-      p.product_properties = product_properties.map { |q| r = q.dup; r.created_at = r.updated_at = nil; r }
-
-      image_dup = lambda { |i| j = i.dup; j.attachment = i.attachment.clone; j }
-
-      variant = master.dup
-      variant.sku = 'COPY OF ' + master.sku
-      variant.deleted_at = nil
-      variant.images = master.images.map { |i| image_dup.call i }
-      variant.price = master.price
-      variant.currency = master.currency
-      p.master = variant
-
-      # don't dup the actual variants, just the characterising types
-      p.option_types = option_types if has_variants?
-
-      # allow site to do some customization
-      p.send(:duplicate_extra, self) if p.respond_to?(:duplicate_extra)
-      p.save!
-      p
+      duplicator = ProductDuplicator.new(self)
+      duplicator.duplicate
     end
 
     # use deleted? rather than checking the attribute directly. this
@@ -224,6 +161,17 @@ module Spree
       self.where([where_str, values.map { |value| "%#{value}%" } * fields.size].flatten)
     end
 
+    # Suitable for displaying only variants that has at least one option value.
+    # There may be scenarios where an option type is removed and along with it
+    # all option values. At that point all variants associated with only those
+    # values should not be displayed to frontend users. Otherwise it breaks the
+    # idea of having variants
+    def variants_and_option_values(current_currency = nil)
+      variants.includes(:option_values).active(current_currency).select do |variant|
+        variant.option_values.any?
+      end
+    end
+
     def empty_option_values?
       options.empty? || options.any? do |opt|
         opt.option_type.option_values.empty?
@@ -237,13 +185,18 @@ module Spree
 
     def set_property(property_name, property_value)
       ActiveRecord::Base.transaction do
-        property = Property.where(:name => property_name).first_or_create!(:presentation => property_name)
-        product_property = ProductProperty.where(:product_id => id, :property_id => property.id).first_or_initialize
+        property = Property.where(name: property_name).first_or_create!(presentation: property_name)
+        product_property = ProductProperty.where(product_id: id, property_id: property.id).first_or_initialize
         product_property.value = property_value
         product_property.save!
       end
     end
 
+    def possible_promotions
+      promotion_ids = promotion_rules.map(&:activator_id).uniq
+      Spree::Promotion.advertised.where(id: promotion_ids).reject(&:expired?)
+    end
+
     private
 
       # Builds variants from a hash of option types & values
@@ -253,7 +206,7 @@ module Spree
         values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
 
         values.each do |ids|
-          variant = variants.create({ :option_value_ids => ids, :price => master.price }, :without_protection => true)
+          variant = variants.create({ option_value_ids: ids, price: master.price }, without_protection: true)
         end
         save
       end
@@ -261,27 +214,12 @@ module Spree
       def add_properties_and_option_types_from_prototype
         if prototype_id && prototype = Spree::Prototype.find_by_id(prototype_id)
           prototype.properties.each do |property|
-            product_properties.create({:property => property}, :without_protection => true)
+            product_properties.create({property: property}, without_protection: true)
           end
           self.option_types = prototype.option_types
         end
       end
 
-      def recalculate_count_on_hand
-        value = if has_variants?
-          variants.sum(:count_on_hand)
-        else
-          (master ? master.count_on_hand : 0)
-        end
-        self[:count_on_hand] = value
-      end
-
-      # the master on_hand is meaningless once a product has variants as the inventory
-      # units are now "contained" within the product variants
-      def set_master_on_hand_to_zero_when_product_has_variants
-        master.on_hand = 0 if has_variants? && Spree::Config[:track_inventory_levels] && !self.on_demand
-      end
-
       # ensures the master variant is flagged as such
       def set_master_variant_defaults
         master.is_master = true
@@ -290,7 +228,7 @@ module Spree
       # there's a weird quirk with the delegate stuff that does not automatically save the delegate object
       # when saving so we force a save using a hook.
       def save_master
-        master.save if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed? || master.default_price.new_record?)))
+        master.save if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed || master.default_price.new_record)))
       end
 
       def ensure_master

data/app/models/spree/product_option_type.rb

@@ -1,7 +1,7 @@
 module Spree
   class ProductOptionType < ActiveRecord::Base
-    belongs_to :product
-    belongs_to :option_type
-    acts_as_list :scope => :product
+    belongs_to :product, class_name: 'Spree::Product'
+    belongs_to :option_type, class_name: 'Spree::OptionType'
+    acts_as_list scope: :product
   end
 end

data/app/models/spree/product_property.rb

@@ -1,14 +1,14 @@
 module Spree
   class ProductProperty < ActiveRecord::Base
-    belongs_to :product
-    belongs_to :property
+    belongs_to :product, class_name: 'Spree::Product'
+    belongs_to :property, class_name: 'Spree::Property'
 
-    validates :property, :presence => true
-    validates :value, :length => { :maximum => 255 }
+    validates :property, presence: true
+    validates :value, length: { maximum: 255 }
 
     attr_accessible :property_name, :value, :position
 
-    default_scope :order => "#{self.table_name}.position"
+    default_scope order: "#{self.table_name}.position"
 
     # virtual attributes for use with AJAX completion stuff
     def property_name
@@ -18,7 +18,7 @@ module Spree
     def property_name=(name)
       unless name.blank?
         unless property = Property.find_by_name(name)
-          property = Property.create(:name => name, :presentation => name)
+          property = Property.create(name: name, presentation: name)
         end
         self.property = property
       end

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

@@ -0,0 +1,71 @@
+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
+
+        delegate :eligible?, :to => :promotion
+
+        before_validation :ensure_action_has_calculator
+        before_destroy :deals_with_adjustments
+
+        # Creates the adjustment related to a promotion for the order passed
+        # through options hash
+        def perform(options = {})
+          order = options[:order]
+          return if order.promotion_credit_exists?(self.promotion)
+
+          self.create_adjustment("#{Spree.t(:promotion)} (#{promotion.name})", order, order)
+        end
+
+        # 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)
+          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)
+          amount = self.calculator.compute(calculable).to_f.abs
+          [(calculable.item_total + calculable.ship_total), amount].min * -1
+        end
+
+        private
+          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
+          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.contents.add(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,29 @@
+module Spree
+  class Promotion
+    module Rules
+      class FirstOrder < PromotionRule
+        attr_reader :user, :email
+
+        def eligible?(order, options = {})
+          @user = order.try(:user) || options[:user]
+          @email = order.email
+
+          if user || email
+            completed_orders.blank? || (completed_orders.first == order)
+          else
+            false
+          end
+        end
+
+        private
+          def completed_orders
+            user ? user.orders.complete : orders_by_email
+          end
+
+          def orders_by_email
+            Spree::Order.where(:email => email).complete
+          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.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,13 @@
+module Spree
+  class Promotion
+    module Rules
+      class UserLoggedIn < PromotionRule
+
+        def eligible?(order, options = {})
+          return order.try(:user).try(:anonymous?) == false
+        end
+
+      end
+    end
+  end
+end

data/app/models/spree/promotion.rb

@@ -0,0 +1,109 @@
+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
+
+    has_many :promotion_actions, foreign_key: :activator_id, autosave: true, dependent: :destroy
+    alias_method :actions, :promotion_actions
+
+    accepts_nested_attributes_for :promotion_actions, :promotion_rules
+
+    attr_accessible :name, :event_name, :code, :match_policy,
+                    :path, :advertise, :description, :usage_limit,
+                    :starts_at, :expires_at, :promotion_rules_attributes,
+                    :promotion_actions_attributes
+
+    validates_associated :rules
+
+    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 }
+
+    # 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
+
+    def self.advertised
+      where(advertise: true)
+    end
+
+    def self.with_code
+      where(event_name: 'spree.checkout.coupon_code_added')
+    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 && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    end
+
+    # Products assigned to all product rules
+    def products
+      @products ||= self.rules.all.inject([]) do |products, rule|
+        rule.respond_to?(:products) ? products << rule.products : products
+      end.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