spree_core 3.0.9 → 3.2.0

data/app/models/spree/product.rb

@@ -21,10 +21,15 @@
 module Spree
   class Product < Spree::Base
     extend FriendlyId
+    include ActsAsTaggable
     friendly_id :slug_candidates, use: :history
 
     acts_as_paranoid
 
+    # we need to have this callback before any dependent: :destroy associations
+    # https://github.com/rails/rails/issues/3458
+    before_destroy :ensure_no_line_items
+
     has_many :product_option_types, dependent: :destroy, inverse_of: :product
     has_many :option_types, through: :product_option_types
     has_many :product_properties, dependent: :destroy, inverse_of: :product
@@ -32,7 +37,15 @@ module Spree
 
     has_many :classifications, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
-    has_and_belongs_to_many :promotion_rules, join_table: :spree_products_promotion_rules
+
+    has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule'
+    has_many :promotion_rules, through: :product_promotion_rules, class_name: 'Spree::PromotionRule'
+
+    has_many :promotions, through: :promotion_rules, class_name: 'Spree::Promotion'
+
+    has_many :possible_promotions, -> { advertised.active }, through: :promotion_rules,
+                                                             class_name: 'Spree::Promotion',
+                                                             source: :promotion
 
     belongs_to :tax_category, class_name: 'Spree::TaxCategory'
     belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products
@@ -43,12 +56,12 @@ module Spree
       class_name: 'Spree::Variant'
 
     has_many :variants,
-      -> { where(is_master: false).order("#{::Spree::Variant.quoted_table_name}.position ASC") },
+      -> { where(is_master: false).order(:position) },
       inverse_of: :product,
       class_name: 'Spree::Variant'
 
     has_many :variants_including_master,
-      -> { order("#{::Spree::Variant.quoted_table_name}.position ASC") },
+      -> { order(:position) },
       inverse_of: :product,
       class_name: 'Spree::Variant',
       dependent: :destroy
@@ -60,16 +73,13 @@ module Spree
     has_many :line_items, through: :variants_including_master
     has_many :orders, through: :line_items
 
-    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, :sku, :price, :currency, :display_amount, :display_price, :weight, :height, :width, :depth,
+                        :is_master, :has_default_price?, :cost_currency, :price_in, :amount_in, :cost_price, :images
 
-    delegate_belongs_to :master, :cost_price
-
-    delegate :images, to: :master, prefix: true
-    alias_method :images, :master_images
+    alias_method :master_images, :images
 
     has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
 
-    after_create :set_master_variant_defaults
     after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
@@ -86,12 +96,17 @@ module Spree
     before_validation :normalize_slug, on: :update
     before_validation :validate_master
 
-    validates :meta_keywords, length: { maximum: 255 }
-    validates :meta_title, length: { maximum: 255 }
-    validates :name, presence: true
-    validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
-    validates :shipping_category_id, presence: true
+    with_options length: { maximum: 255 }, allow_blank: true do
+      validates :meta_keywords
+      validates :meta_title
+    end
+    with_options presence: true do
+      validates :name, :shipping_category
+      validates :price, if: proc { Spree::Config[:require_master_price] }
+    end
+
     validates :slug, length: { minimum: 3 }, allow_blank: true, uniqueness: true
+    validate :discontinue_on_must_be_later_than_available_on, if: -> { available_on && discontinue_on }
 
     attr_accessor :option_values_hash
 
@@ -100,7 +115,8 @@ module Spree
     alias :options :product_option_types
 
     self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
-    self.whitelisted_ransackable_attributes = %w[description name slug]
+    self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on]
+    self.whitelisted_ransackable_scopes = %w[not_discontinued]
 
     # the master variant is not a member of the variants array
     def has_variants?
@@ -108,11 +124,7 @@ module Spree
     end
 
     def tax_category
-      if self[:tax_category_id].nil?
-        TaxCategory.where(is_default: true).first
-      else
-        TaxCategory.find(self[:tax_category_id])
-      end
+      super || TaxCategory.find_by(is_default: true)
     end
 
     # Adding properties and option types on creation based on a chosen prototype
@@ -124,9 +136,10 @@ module Spree
     # Ensures option_types and product_option_types exist for keys in option_values_hash
     def ensure_option_types_exist_for_values_hash
       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) unless product_option_types.pluck(:option_type_id).include?(id)
+      required_option_type_ids = option_values_hash.keys.map(&:to_i)
+      missing_option_type_ids = required_option_type_ids - option_type_ids
+      missing_option_type_ids.each do |id|
+        product_option_types.create(option_type_id: id)
       end
     end
 
@@ -148,7 +161,20 @@ module Spree
     # deleted products and products with nil or future available_on date
     # are not available
     def available?
-      !(available_on.nil? || available_on.future?) && !deleted?
+      !(available_on.nil? || available_on.future?) && !deleted? && !discontinued?
+    end
+
+    def discontinue!
+      update_attribute(:discontinue_on, Time.current)
+    end
+
+    def discontinued?
+      !!discontinue_on && discontinue_on <= Time.current
+    end
+
+    # determine if any variant (including master) can be supplied
+    def can_supply?
+      variants_including_master.any?(&:can_supply?)
     end
 
     # split variants list into hash which shows mapping of opt value onto matching variants
@@ -159,11 +185,10 @@ module Spree
     end
 
     def self.like_any(fields, values)
-      where fields.map { |field|
-        values.map { |value|
-          arel_table[field].matches("%#{value}%")
-        }.inject(:or)
-      }.inject(:or)
+      conditions = fields.product(values).map do |(field, value)|
+        arel_table[field].matches("%#{value}%")
+      end
+      where conditions.inject(:or)
     end
 
     # Suitable for displaying only variants that has at least one option value.
@@ -184,29 +209,19 @@ module Spree
     end
 
     def property(property_name)
-      return nil unless prop = properties.find_by(name: property_name)
-      product_properties.find_by(property: prop).try(:value)
+      product_properties.joins(:property).find_by(spree_properties: { name: property_name }).try(:value)
     end
 
-    def set_property(property_name, property_value)
-      ActiveRecord::Base.transaction do
+    def set_property(property_name, property_value, property_presentation = property_name)
+      ApplicationRecord.transaction do
         # Works around spree_i18n #301
-        property = if Property.exists?(name: property_name)
-          Property.where(name: property_name).first
-        else
-          Property.create(name: property_name, presentation: property_name)
-        end
+        property = Property.create_with(presentation: property_presentation).find_or_create_by(name: property_name)
         product_property = ProductProperty.where(product: self, property: property).first_or_initialize
         product_property.value = property_value
         product_property.save!
       end
     end
 
-    def possible_promotions
-      promotion_ids = promotion_rules.map(&:promotion_id).uniq
-      Spree::Promotion.advertised.where(id: promotion_ids).reject(&:expired?)
-    end
-
     def total_on_hand
       if any_variants_not_track_inventory?
         Float::INFINITY
@@ -219,7 +234,15 @@ module Spree
     # which would make AR's default finder return nil.
     # This is a stopgap for that little problem.
     def master
-      super || variants_including_master.with_deleted.where(is_master: true).first
+      super || variants_including_master.with_deleted.find_by(is_master: true)
+    end
+
+    def brand
+      taxons.joins(:taxonomy).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_brands_name) })
+    end
+
+    def category
+      taxons.joins(:taxonomy).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_categories_name) })
     end
 
     private
@@ -250,12 +273,12 @@ module Spree
       values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
 
       values.each do |ids|
-        variant = variants.create(
+        variants.create(
           option_value_ids: ids,
           price: master.price
         )
       end
-      save
+      throw(:abort) unless save
     end
 
     def ensure_master
@@ -269,7 +292,7 @@ module Spree
 
     def punch_slug
       # punch slug with date prefix to allow reuse of original
-      update_column :slug, "#{Time.now.to_i}_#{slug}"[0..254] unless frozen?
+      update_column :slug, "#{Time.current.to_i}_#{slug}"[0..254] unless frozen?
     end
 
     def update_slug_history
@@ -320,11 +343,6 @@ module Spree
       end
     end
 
-    # ensures the master variant is flagged as such
-    def set_master_variant_defaults
-      master.is_master = true
-    end
-
     # Try building a slug based on the following fields in increasing order of specificity.
     def slug_candidates
       [
@@ -352,10 +370,23 @@ module Spree
       Spree::Taxonomy.where(id: taxonomy_ids).update_all(updated_at: Time.current)
     end
 
+    def ensure_no_line_items
+      if line_items.any?
+        errors.add(:base, Spree.t(:cannot_destroy_if_attached_to_line_items))
+        throw(:abort)
+      end
+    end
+
     def remove_taxon(taxon)
       removed_classifications = classifications.where(taxon: taxon)
       removed_classifications.each &:remove_from_list
     end
+
+    def discontinue_on_must_be_later_than_available_on
+      if discontinue_on < available_on
+        errors.add(:discontinue_on, :invalid_date_range)
+      end
+    end
   end
 end
 

data/app/models/spree/product_option_type.rb

@@ -1,7 +1,12 @@
 module Spree
   class ProductOptionType < Spree::Base
-    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types
-    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
+    with_options inverse_of: :product_option_types do
+      belongs_to :product, class_name: 'Spree::Product'
+      belongs_to :option_type, class_name: 'Spree::OptionType'
+    end
     acts_as_list scope: :product
+
+    validates :product, :option_type, presence: true
+    validates :product_id, uniqueness: { scope: :option_type_id }, allow_nil: true
   end
 end

data/app/models/spree/product_promotion_rule.rb

@@ -0,0 +1,9 @@
+module Spree
+  class ProductPromotionRule < Spree::Base
+    belongs_to :product, class_name: 'Spree::Product'
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+
+    validates :product, :promotion_rule, presence: true
+    validates :product_id, uniqueness: { scope: :promotion_rule_id }, allow_nil: true
+  end
+end

data/app/models/spree/product_property.rb

@@ -2,28 +2,27 @@ module Spree
   class ProductProperty < Spree::Base
     acts_as_list scope: :product
 
-    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
-    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
+    with_options inverse_of: :product_properties do
+      belongs_to :product, touch: true, class_name: 'Spree::Product'
+      belongs_to :property, class_name: 'Spree::Property'
+    end
 
     validates :property, presence: true
 
-    validates_with Spree::Validations::DbMaximumLengthValidator, field: :value
+    validates :value, db_maximum_length: true
 
-    default_scope { order("#{self.table_name}.position") }
+    default_scope { order(:position) }
 
     self.whitelisted_ransackable_attributes = ['value']
+    self.whitelisted_ransackable_associations = ['property']
 
     # virtual attributes for use with AJAX completion stuff
-    def property_name
-      property.name if property
-    end
+    delegate :name, to: :property, prefix: true, allow_nil: true
 
     def property_name=(name)
       if name.present?
         # don't use `find_by :name` to workaround globalize/globalize#423 bug
-        property = Property.where(name: name).first ||
-                   Property.create(name: name, presentation: name)
-        self.property = property
+        self.property = Property.where(name: name).first_or_create(presentation: name)
       end
     end
   end

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

@@ -13,7 +13,7 @@ module Spree
         end
 
         def compute_amount(order)
-          [(order.item_total + order.ship_total), compute(order)].min * -1
+          [(order.item_total + order.ship_total - order.shipping_discount), compute(order)].min * -1
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Spree
         has_many :promotion_action_line_items, foreign_key: :promotion_action_id
         accepts_nested_attributes_for :promotion_action_line_items
 
-        delegate :eligible?, :to => :promotion
+        delegate :eligible?, to: :promotion
 
         # Adds a line item to the Order if the promotion is eligible
         #
@@ -37,7 +37,7 @@ module Spree
         # needs to be manually removed from the order by the customer
         def perform(options = {})
           order = options[:order]
-          return unless self.eligible? order
+          return unless eligible? order
 
           action_taken = false
           promotion_action_line_items.each do |item|
@@ -50,12 +50,30 @@ module Spree
           action_taken
         end
 
+        # Called by promotion handler when a promotion is removed
+        # This will find any line item matching the ones defined in the PromotionAction
+        # and remove the same quantity as was added by the PromotionAction.
+        # Should help to prevent some of cases listed above the #perform method
+        def revert(options = {})
+          order = options[:order]
+          return if eligible?(order)
+
+          action_taken = false
+          promotion_action_line_items.each do |item|
+            line_item = order.find_line_item_by_variant(item.variant)
+            next unless line_item.present?
+            order.contents.remove(item.variant, (item.quantity || 1))
+            action_taken = true
+          end
+
+          action_taken
+        end
+
         # Checks that there's enough stock to add the line item to the order
         def item_available?(item)
           quantifier = Spree::Stock::Quantifier.new(item.variant)
           quantifier.can_supply? item.quantity
         end
-
       end
     end
   end

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

@@ -0,0 +1,23 @@
+# A rule to limit a promotion based on shipment country.
+module Spree
+  class Promotion
+    module Rules
+      class Country < PromotionRule
+        preference :country_id, :integer
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          country_id = options[:country_id] || order.ship_address.try(:country_id)
+          unless country_id.eql?(preferred_country_id || Spree::Country.default)
+            eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,20 @@
 module Spree
   class Promotion
     module Rules
+      module OptionValueWithNumerificationSupport
+        def preferred_eligible_values
+          values = super || {}
+          Hash[values.keys.map(&:to_i).zip(
+            values.values.map do |v|
+              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+            end
+          )]
+        end
+      end
+
       class OptionValue < PromotionRule
+        prepend OptionValueWithNumerificationSupport
+
         MATCH_POLICIES = %w(any)
         preference :match_policy, :string, default: MATCH_POLICIES.first
         preference :eligible_values, :hash
@@ -24,16 +37,6 @@ module Spree
           product_ids.include?(pid) && (value_ids(pid) - ovids).empty?
         end
 
-        def preferred_eligible_values_with_numerification
-          values = preferred_eligible_values_without_numerification || {}
-          Hash[values.keys.map(&:to_i).zip(
-            values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
-            end
-          )]
-        end
-        alias_method_chain :preferred_eligible_values, :numerification
-
         private
 
         def product_ids

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

@@ -5,7 +5,9 @@ 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'
+        has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule',
+                                           foreign_key: :promotion_rule_id
+        has_many :products, through: :product_promotion_rules, class_name: 'Spree::Product'
 
         MATCH_POLICIES = %w(any all none)
         preference :match_policy, :string, default: MATCH_POLICIES.first

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

@@ -2,7 +2,8 @@ module Spree
   class Promotion
     module Rules
       class Taxon < PromotionRule
-        has_and_belongs_to_many :taxons, class_name: '::Spree::Taxon', join_table: 'spree_taxons_promotion_rules', foreign_key: 'promotion_rule_id'
+        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', foreign_key: 'promotion_rule_id'
+        has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
 
         MATCH_POLICIES = %w(any all)
         preference :match_policy, default: MATCH_POLICIES.first
@@ -43,7 +44,7 @@ module Spree
 
         # All taxons in an order
         def order_taxons(order)
-          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).uniq
+          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).distinct
         end
 
         # ids of taxons rules and taxons rules children

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

@@ -4,10 +4,10 @@ module Spree
       class User < PromotionRule
         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',
-          association_foreign_key: :user_id
+        has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser',
+                                        foreign_key: :promotion_rule_id,
+                                        dependent: :destroy
+        has_many :users, through: :promotion_rule_users, class_name: "::#{Spree.user_class.to_s}"
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)

data/app/models/spree/promotion.rb

@@ -13,7 +13,8 @@ module Spree
     has_many :promotion_actions, autosave: true, dependent: :destroy
     alias_method :actions, :promotion_actions
 
-    has_and_belongs_to_many :orders, join_table: 'spree_orders_promotions'
+    has_many :order_promotions, class_name: 'Spree::OrderPromotion'
+    has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
 
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
@@ -22,29 +23,31 @@ module Spree
     validates :name, presence: true
     validates :path, uniqueness: { allow_blank: true }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
-    validates :description, length: { maximum: 255 }
+    validates :description, length: { maximum: 255 }, allow_blank: true
+    validate :expires_at_must_be_later_than_starts_at, if: -> { starts_at && expires_at }
 
     before_save :normalize_blank_values
 
-    scope :coupons, ->{ where("#{table_name}.code IS NOT NULL") }
+    scope :coupons, -> { where.not(code: nil) }
+    scope :advertised, -> { where(advertise: true) }
+    scope :applied, lambda {
+      joins(<<-SQL).distinct
+        INNER JOIN spree_order_promotions
+        ON spree_order_promotions.promotion_id = #{table_name}.id
+      SQL
+    }
 
-    order_join_table = reflect_on_association(:orders).join_table
-
-    scope :applied, -> { joins("INNER JOIN #{order_join_table} ON #{order_join_table}.promotion_id = #{table_name}.id").uniq }
-
-    self.whitelisted_ransackable_attributes = ['code', 'path', 'promotion_category_id']
-
-    def self.advertised
-      where(advertise: true)
-    end
+    self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id', 'code']
 
     def self.with_coupon_code(coupon_code)
-      where("lower(#{self.table_name}.code) = ?", coupon_code.strip.downcase).first
+      where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase)
+        .includes(:promotion_actions).where.not(spree_promotion_actions: { id: nil })
+        .first
     end
 
     def self.active
-      where('spree_promotions.starts_at IS NULL OR spree_promotions.starts_at < ?', Time.now).
-        where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.now)
+      where('spree_promotions.starts_at IS NULL OR spree_promotions.starts_at < ?', Time.current).
+        where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.current)
     end
 
     def self.order_activatable?(order)
@@ -52,7 +55,7 @@ module Spree
     end
 
     def expired?
-      !!(starts_at && Time.now < starts_at || expires_at && Time.now > expires_at)
+      !!(starts_at && Time.current < starts_at || expires_at && Time.current > expires_at)
     end
 
     def activate(payload)
@@ -77,10 +80,37 @@ module Spree
         self.save
       end
 
-      return action_taken
+      action_taken
     end
 
-    # called anytime order.update! happens
+    # Called when a promotion is removed from the cart
+    def deactivate(payload)
+      order = payload[:order]
+      return unless self.class.order_activatable?(order)
+
+      payload[:promotion] = self
+
+      # Track results from actions to see if any action has been taken.
+      # Actions should return nil/false if no action has been taken.
+      # If an action returns true, then an action has been taken.
+      results = actions.map do |action|
+        action.revert(payload) if action.respond_to?(:revert)
+      end
+
+      # If an action has been taken, report back to whatever `d this promotion.
+      action_taken = results.include?(true)
+
+      if action_taken
+        # connect to the order
+        # create the join_table entry.
+        orders << order
+        save
+      end
+
+      action_taken
+    end
+
+    # called anytime order.update_with_updater! happens
     def eligible?(promotable)
       return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)
       !!eligible_rules(promotable, {})
@@ -128,7 +158,7 @@ module Spree
 
     def adjusted_credits_count(promotable)
       adjustments = promotable.is_a?(Order) ? promotable.all_adjustments : promotable.adjustments
-      credits_count - adjustments.promotion.where(:source_id => actions.pluck(:id)).count
+      credits_count - adjustments.promotion.where(source_id: actions.pluck(:id)).size
     end
 
     def credits
@@ -192,5 +222,11 @@ module Spree
     def match_all?
       match_policy == 'all'
     end
+
+    def expires_at_must_be_later_than_starts_at
+      if expires_at < starts_at
+        errors.add(:expires_at, :invalid_date_range)
+      end
+    end
   end
 end

data/app/models/spree/promotion_action.rb

@@ -1,4 +1,4 @@
-# Base class for all types of promotion action.
+## 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 < Spree::Base
@@ -18,8 +18,8 @@ module Spree
 
     protected
 
-    def label(amount)
-      "#{Spree.t(:promotion)} (#{promotion.name})"
+    def label
+      Spree.t(:promotion_label, name: promotion.name)
     end
   end
 end

data/app/models/spree/promotion_category.rb

@@ -1,6 +1,6 @@
 module Spree
   class PromotionCategory < Spree::Base
-    validates_presence_of :name
+    validates :name, presence: true
     has_many :promotions
   end
 end