spree_core 4.2.5 → 4.3.0

data/app/models/spree/product_property.rb

@@ -1,29 +1,44 @@
 module Spree
   class ProductProperty < Spree::Base
+    include Spree::FilterParam
+
+    auto_strip_attributes :value
+
     acts_as_list scope: :product
 
     with_options inverse_of: :product_properties do
       belongs_to :product, touch: true, class_name: 'Spree::Product'
-      belongs_to :property, class_name: 'Spree::Property'
+      belongs_to :property, touch: true, class_name: 'Spree::Property'
     end
 
     validates :property, presence: true
-
-    validates :value, db_maximum_length: true
+    validates :property_id, uniqueness: { scope: :product_id }
 
     default_scope { order(:position) }
 
-    self.whitelisted_ransackable_attributes = ['value']
+    scope :filterable, -> { joins(:property).where(Property.table_name => { filterable: true }) }
+    scope :for_products, ->(products) { joins(:product).merge(products) }
+
+    self.whitelisted_ransackable_attributes = ['value', 'filter_param']
     self.whitelisted_ransackable_associations = ['property']
 
     # virtual attributes for use with AJAX completion stuff
     delegate :name, :presentation, to: :property, prefix: true, allow_nil: true
 
     def property_name=(name)
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `ProductProperty#property_name=` is deprecated and will be removed in Spree 5.0.
+      DEPRECATION
       if name.present?
         # don't use `find_by :name` to workaround globalize/globalize#423 bug
         self.property = Property.where(name: name).first_or_create(presentation: name)
       end
     end
+
+    protected
+
+    def param_candidate
+      value
+    end
   end
 end

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

@@ -11,7 +11,7 @@ module Spree
 
         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)
+          unless country_id.eql?(preferred_country_id || order.store.default_country_id)
             eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
           end
 

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

@@ -2,7 +2,7 @@ module Spree
   class Promotion
     module Rules
       class FirstOrder < PromotionRule
-        attr_reader :user, :email
+        attr_reader :user, :email, :store
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
@@ -11,6 +11,7 @@ module Spree
         def eligible?(order, options = {})
           @user = order.try(:user) || options[:user]
           @email = order.email
+          @store = order.store
 
           if user || email
             if !completed_orders.blank? && completed_orders.first != order
@@ -26,11 +27,11 @@ module Spree
         private
 
         def completed_orders
-          user ? user.orders.complete : orders_by_email
+          user ? user.orders.for_store(store).complete : orders_by_email
         end
 
         def orders_by_email
-          Spree::Order.where(email: email).complete
+          store.orders.where(email: email).complete
         end
       end
     end

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

@@ -30,7 +30,12 @@ module Spree
         end
 
         def actionable?(line_item)
-          taxon_product_ids.include? line_item.variant.product_id
+          store = line_item.order.store
+
+          store.products.
+            joins(:classifications).
+            where(Spree::Classification.table_name => { taxon_id: taxon_ids, product_id: line_item.product_id }).
+            exists?
         end
 
         def taxon_ids_string
@@ -39,14 +44,16 @@ module Spree
 
         def taxon_ids_string=(s)
           ids = s.to_s.split(',').map(&:strip)
-          self.taxons = Spree::Taxon.find(ids)
+          self.taxons = Spree::Taxon.for_stores(stores).find(ids)
         end
 
         private
 
         # 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 }).distinct
+          taxon_ids = Spree::Classification.where(product_id: order.product_ids).pluck(:taxon_id).uniq
+
+          order.store.taxons.where(id: taxon_ids)
         end
 
         # ids of taxons rules and taxons rules children
@@ -62,10 +69,6 @@ module Spree
         def taxons_in_order_including_parents(order)
           order_taxons_in_taxons_and_children(order).inject([]) { |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
         end
-
-        def taxon_product_ids
-          Spree::Product.joins(:taxons).where(spree_taxons: { id: taxons.pluck(:id) }).pluck(:id).uniq
-        end
       end
     end
   end

data/app/models/spree/promotion.rb

@@ -1,5 +1,7 @@
 module Spree
   class Promotion < Spree::Base
+    include MultiStoreResource
+
     MATCH_POLICIES = %w(all any)
     UNACTIVATABLE_ORDER_STATES = ['complete', 'awaiting_return', 'returned']
 
@@ -16,19 +18,18 @@ module Spree
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
 
+    has_and_belongs_to_many :stores, class_name: 'Spree::Store', join_table: 'spree_promotions_stores'
+
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
     validates_associated :rules
 
     validates :name, presence: true
-    validates :path, :code, uniqueness: { case_sensitive: false, allow_blank: true }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     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
-
-    before_validation :normalize_code
+    auto_strip_attributes :code, :path, :name
 
     scope :coupons, -> { where.not(code: nil) }
     scope :advertised, -> { where(advertise: true) }
@@ -44,7 +45,7 @@ module Spree
     def self.with_coupon_code(coupon_code)
       where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase).
         includes(:promotion_actions).where.not(spree_promotion_actions: { id: nil }).
-        first
+        last
     end
 
     def self.active
@@ -212,16 +213,6 @@ module Spree
       end
     end
 
-    def normalize_blank_values
-      [:code, :path].each do |column|
-        self[column] = nil if self[column].blank?
-      end
-    end
-
-    def normalize_code
-      self.code = code.strip if code.present?
-    end
-
     def match_all?
       match_policy == 'all'
     end

data/app/models/spree/promotion_handler/cart.rb

@@ -13,12 +13,13 @@ module Spree
     # the promotions system accurate and performant. Here they can plug custom
     # handler to activate promos as they wish once an item is added to cart
     class Cart
-      attr_reader :line_item, :order
+      attr_reader :line_item, :order, :store
       attr_accessor :error, :success
 
       def initialize(order, line_item = nil)
         @order = order
         @line_item = line_item
+        @store = order.store
       end
 
       def activate
@@ -34,7 +35,11 @@ module Spree
       private
 
       def promotions
-        Promotion.find_by_sql("#{order.promotions.active.to_sql} UNION #{Promotion.active.where(code: nil, path: nil).to_sql}")
+        promotion_scope.find_by_sql("#{order.promotions.active.to_sql} UNION #{promotion_scope.active.where(code: nil, path: nil).to_sql}")
+      end
+
+      def promotion_scope
+        ::Spree::Promotion.for_store(store)
       end
     end
   end

data/app/models/spree/promotion_handler/coupon.rb

@@ -1,18 +1,19 @@
 module Spree
   module PromotionHandler
     class Coupon
-      attr_reader :order
+      attr_reader :order, :store
       attr_accessor :error, :success, :status_code
 
       def initialize(order)
         @order = order
+        @store = order.store
       end
 
       def apply
         if order.coupon_code.present?
           if promotion.present? && promotion.actions.exists?
             handle_present_promotion
-          elsif Promotion.with_coupon_code(order.coupon_code).try(:expired?)
+          elsif store.promotions.with_coupon_code(order.coupon_code).try(:expired?)
             set_error_code :coupon_code_expired
           else
             set_error_code :coupon_code_not_found
@@ -51,7 +52,7 @@ module Spree
       end
 
       def promotion
-        @promotion ||= Promotion.active.includes(
+        @promotion ||= store.promotions.active.includes(
           :promotion_rules, :promotion_actions
         ).with_coupon_code(order.coupon_code)
       end
@@ -75,7 +76,7 @@ module Spree
           line_item = order.find_line_item_by_variant(item.variant)
           next if line_item.blank?
 
-          Spree::Dependencies.cart_remove_item_service.constantize.call(order: order, item: item.variant, quantity: item.quantity)
+          Spree::Dependencies.cart_remove_item_service.constantize.call(order: order, variant: item.variant, quantity: item.quantity)
         end
       end
 

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

@@ -2,12 +2,13 @@ module Spree
   module PromotionHandler
     # Used for activating promotions with shipping rules
     class FreeShipping
-      attr_reader :order, :order_promo_ids
+      attr_reader :order, :order_promo_ids, :store
       attr_accessor :error, :success
 
       def initialize(order)
         @order = order
-        @order_promo_ids = order.promotions.pluck(:id)
+        @store = order.store
+        @order_promo_ids = order.promotions.ids
       end
 
       def activate
@@ -21,10 +22,8 @@ module Spree
       private
 
       def promotions
-        Spree::Promotion.active.where(
-          id: Spree::Promotion::Actions::FreeShipping.pluck(:promotion_id),
-          path: nil
-        )
+        store.promotions.active.joins(:promotion_actions).
+          where(Spree::PromotionAction.table_name => { type: 'Spree::Promotion::Actions::FreeShipping' }, path: nil).distinct
       end
     end
   end

data/app/models/spree/promotion_handler/page.rb

@@ -1,10 +1,11 @@
 module Spree
   module PromotionHandler
     class Page
-      attr_reader :order, :path
+      attr_reader :order, :path, :store
 
       def initialize(order, path)
         @order = order
+        @store = order.store
         @path = path.gsub(/\A\//, '')
       end
 
@@ -17,7 +18,7 @@ module Spree
       private
 
       def promotion
-        @promotion ||= Promotion.active.find_by(path: path)
+        @promotion ||= store.promotions.active.find_by(path: path)
       end
     end
   end

data/app/models/spree/promotion_handler/promotion_duplicator.rb

@@ -11,6 +11,7 @@ module Spree
         @new_promotion.path = "#{@promotion.path}_#{@random_string}"
         @new_promotion.name = "New #{@promotion.name}"
         @new_promotion.code = "#{@promotion.code}_#{@random_string}"
+        @new_promotion.stores = @promotion.stores
 
         ActiveRecord::Base.transaction do
           @new_promotion.save

data/app/models/spree/promotion_rule.rb

@@ -3,6 +3,8 @@ module Spree
   class PromotionRule < Spree::Base
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
 
+    delegate :stores, to: :promotion
+
     scope :of_type, ->(t) { where(type: t) }
 
     validate :unique_per_promotion, on: :create

data/app/models/spree/property.rb

@@ -1,5 +1,9 @@
 module Spree
   class Property < Spree::Base
+    include Spree::FilterParam
+
+    auto_strip_attributes :name, :presentation
+
     has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
     has_many :prototypes, through: :property_prototypes, class_name: 'Spree::Prototype'
 
@@ -9,15 +13,38 @@ module Spree
     validates :name, :presentation, presence: true
 
     scope :sorted, -> { order(:name) }
+    scope :filterable, -> { where(filterable: true) }
 
     after_touch :touch_all_products
+    after_save :ensure_product_properties_have_filter_params
 
-    self.whitelisted_ransackable_attributes = ['presentation']
+    self.whitelisted_ransackable_attributes = ['presentation', 'filterable']
+
+    def uniq_values(product_properties_scope: nil)
+      with_uniq_values_cache_key(product_properties_scope) do
+        properties = product_properties
+        properties = properties.where(id: product_properties_scope) if product_properties_scope.present?
+        properties.where.not(value: [nil, '']).pluck(:filter_param, :value).uniq
+      end
+    end
 
     private
 
     def touch_all_products
       products.update_all(updated_at: Time.current)
     end
+
+    def with_uniq_values_cache_key(product_properties_scope, &block)
+      return block.call if product_properties_scope.present?
+
+      uniq_values_cache_key = ['property-uniq-values', cache_key_with_version]
+      Rails.cache.fetch(uniq_values_cache_key) { block.call }
+    end
+
+    def ensure_product_properties_have_filter_params
+      return unless filterable?
+
+      product_properties.where(filter_param: [nil, '']).where.not(value: [nil, '']).find_each(&:save)
+    end
   end
 end

data/app/models/spree/reimbursement.rb

@@ -139,7 +139,9 @@ module Spree
     end
 
     def send_reimbursement_email
-      Spree::ReimbursementMailer.reimbursement_email(id).deliver_later
+      # you can overwrite this method in your application / extension to send out the confirmation email
+      # or use `spree_emails` gem
+      # YourEmailVendor.deliver_reimbursement_email(id) # `id` = ID of the Reimbursement being sent, you can also pass the entire object using `self`
     end
 
     # If there are multiple different reimbursement types for a single

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -51,7 +51,8 @@ module Spree
         category: category,
         created_by: Spree::StoreCredit.default_created_by,
         memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
-        currency: reimbursement.order.currency
+        currency: reimbursement.order.currency,
+        store: reimbursement.order.store
       }
     end
 

data/app/models/spree/shipment_handler.rb

@@ -25,10 +25,12 @@ module Spree
       send_shipped_email
     end
 
-    private
+    protected
 
     def send_shipped_email
-      ShipmentMailer.shipped_email(@shipment.id).deliver_later
+      # you can overwrite this method in your application / extension to send out the confirmation email
+      # or use `spree_emails` gem
+      # YourEmailVendor.deliver_shipment_notification_email(@shipment.id)
     end
 
     def update_order_shipment_state

data/app/models/spree/stock/quantifier.rb

@@ -9,15 +9,15 @@ module Spree
       end
 
       def total_on_hand
-        if variant.should_track_inventory?
-          stock_items.sum(:count_on_hand)
-        else
-          Float::INFINITY
-        end
+        @total_on_hand ||= if variant.should_track_inventory?
+                             stock_items.sum(:count_on_hand)
+                           else
+                             Float::INFINITY
+                           end
       end
 
       def backorderable?
-        stock_items.any?(&:backorderable)
+        @backorderable ||= stock_items.any?(&:backorderable)
       end
 
       def can_supply?(required = 1)

data/app/models/spree/stock_location.rb

@@ -2,6 +2,7 @@ module Spree
   class StockLocation < Spree::Base
     has_many :shipments
     has_many :stock_items, dependent: :delete_all, inverse_of: :stock_location
+    has_many :variants, through: :stock_items
     has_many :stock_movements, through: :stock_items
 
     belongs_to :state, class_name: 'Spree::State', optional: true
@@ -14,6 +15,7 @@ module Spree
 
     after_create :create_stock_items, if: :propagate_all_variants?
     after_save :ensure_one_default
+    after_update :conditional_touch_records
 
     def state_text
       state.try(:abbr) || state.try(:name) || state_name
@@ -134,5 +136,12 @@ module Spree
         StockLocation.where(default: true).where.not(id: id).update_all(default: false)
       end
     end
+
+    def conditional_touch_records
+      return unless active_changed?
+
+      stock_items.update_all(updated_at: Time.current)
+      variants.update_all(updated_at: Time.current)
+    end
   end
 end