spree_core 4.2.5 → 4.3.0.rc1

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.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/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_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']
 
+    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/store.rb

@@ -1,7 +1,41 @@
 module Spree
   class Store < Spree::Base
+    MAILER_LOGO_CONTENT_TYPES = ['image/png', 'image/jpg', 'image/jpeg'].freeze
+    FAVICON_CONTENT_TYPES = ['image/png', 'image/x-icon', 'image/vnd.microsoft.icon'].freeze
+
     has_many :orders, class_name: 'Spree::Order'
-    has_many :payment_methods, class_name: 'Spree::PaymentMethod'
+    has_many :line_items, through: :orders, class_name: 'Spree::LineItem'
+    has_many :shipments, through: :orders, class_name: 'Spree::Shipment'
+    has_many :payments, through: :orders, class_name: 'Spree::Payment'
+    has_many :return_authorizations, through: :orders, class_name: 'Spree::ReturnAuthorization'
+    # has_many :reimbursements, through: :orders, class_name: 'Spree::Reimbursement' FIXME: we should fetch this via Customer Return
+
+    has_many :store_payment_methods, class_name: 'Spree::StorePaymentMethod'
+    has_many :payment_methods, through: :store_payment_methods, class_name: 'Spree::PaymentMethod'
+
+    has_many :cms_pages, class_name: 'Spree::CmsPage'
+    has_many :cms_sections, through: :cms_pages, class_name: 'Spree::CmsSection'
+
+    has_many :menus, class_name: 'Spree::Menu'
+    has_many :menu_items, through: :menus, class_name: 'Spree::MenuItem'
+
+    has_many :store_products, class_name: 'Spree::StoreProduct', dependent: :destroy
+    has_many :products, through: :store_products, class_name: 'Spree::Product'
+    has_many :product_properties, through: :products, class_name: 'Spree::ProductProperty'
+    has_many :variants, through: :products, class_name: 'Spree::Variant', source: :variants_including_master
+    has_many :stock_items, through: :variants, class_name: 'Spree::StockItem'
+    has_many :inventory_units, through: :variants, class_name: 'Spree::InventoryUnit'
+    has_many :customer_returns, class_name: 'Spree::CustomerReturn', inverse_of: :store
+
+    has_many :store_credits, class_name: 'Spree::StoreCredit'
+    has_many :store_credit_events, through: :store_credits, class_name: 'Spree::StoreCreditEvent'
+
+    has_many :taxonomies, class_name: 'Spree::Taxonomy'
+    has_many :taxons, through: :taxonomies, class_name: 'Spree::Taxon'
+
+    has_many :store_promotions, class_name: 'Spree::StorePromotion'
+    has_many :promotions, through: :store_promotions, class_name: 'Spree::Promotion'
+
     belongs_to :default_country, class_name: 'Spree::Country'
     belongs_to :checkout_zone, class_name: 'Spree::Zone'
 
@@ -18,13 +52,20 @@ module Spree
       validates :new_order_notifications_email, email: { allow_blank: true }
     end
 
+    default_scope { order(created_at: :asc) }
+
     has_one_attached :logo
     has_one_attached :mailer_logo
+    has_one_attached :favicon_image
 
-    validates :mailer_logo, content_type: ['image/png', 'image/jpg', 'image/jpeg']
+    validates :mailer_logo, content_type: MAILER_LOGO_CONTENT_TYPES
+    validates :favicon_image, content_type: FAVICON_CONTENT_TYPES,
+                              dimension: { max: 256..256 },
+                              aspect_ratio: :square,
+                              size: { less_than_or_equal_to: 1.megabyte }
 
     before_save :ensure_default_exists_and_is_unique
-    before_save :ensure_supported_currencies, :ensure_supported_locales
+    before_save :ensure_supported_currencies, :ensure_supported_locales, :ensure_default_country
     before_destroy :validate_not_default
 
     scope :by_url, ->(url) { where('url like ?', "%#{url}%") }
@@ -33,9 +74,12 @@ module Spree
 
     alias_attribute :contact_email, :customer_support_email
 
-    def self.current(domain = nil)
-      current_store = domain ? Store.by_url(domain).first : nil
-      current_store || Store.default
+    def self.current(url = nil)
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `Spree::Store.current` is deprecated and will be removed in Spree 5
+        Spree::Stores::FindCurrent.new(url: "http://example.com") instead
+      DEPRECATION
+      Stores::FindCurrent.new(url: url).execute
     end
 
     def self.default
@@ -50,12 +94,34 @@ module Spree
       end
     end
 
+    def default_menu(location)
+      menu = menus.find_by(location: location, locale: default_locale) || menus.find_by(location: location)
+
+      menu.root if menu.present?
+    end
+
     def supported_currencies_list
       @supported_currencies_list ||= (read_attribute(:supported_currencies).to_s.split(',') << default_currency).sort.map(&:to_s).map do |code|
         ::Money::Currency.find(code.strip)
       end.uniq.compact
     end
 
+    def homepage(requested_locale)
+      cms_pages.by_locale(requested_locale).find_by(type: 'Spree::Cms::Pages::Homepage') ||
+        cms_pages.by_locale(default_locale).find_by(type: 'Spree::Cms::Pages::Homepage') ||
+        cms_pages.find_by(type: 'Spree::Cms::Pages::Homepage')
+    end
+
+    def seo_meta_description
+      if meta_description.present?
+        meta_description
+      elsif seo_title.present?
+        seo_title
+      else
+        name
+      end
+    end
+
     def supported_locales_list
       # TODO: add support of multiple supported languages to a single Store
       @supported_locales_list ||= (read_attribute(:supported_locales).to_s.split(',') << default_locale).compact.uniq.sort
@@ -71,7 +137,7 @@ module Spree
       @formatted_url ||= if url.match(/http:\/\/|https:\/\//)
                            url
                          else
-                           Rails.env.development? ? "http://#{url}" : "https://#{url}"
+                           Rails.env.development? || Rails.env.test? ? "http://#{url}" : "https://#{url}"
                          end
     end
 
@@ -87,6 +153,12 @@ module Spree
       @checkout_zone_or_default ||= checkout_zone || Spree::Zone.default_checkout_zone
     end
 
+    def favicon
+      return unless favicon_image.attached?
+
+      favicon_image.variant(resize: '32x32')
+    end
+
     private
 
     def ensure_default_exists_and_is_unique
@@ -124,5 +196,16 @@ module Spree
       Rails.cache.delete('default_store')
       Rails.cache.delete('stores_available_locales')
     end
+
+    def ensure_default_country
+      return unless has_attribute?(:default_country_id)
+      return if default_country.present? && (checkout_zone.blank? || checkout_zone.country_list.blank? || checkout_zone.country_list.include?(default_country))
+
+      self.default_country = if checkout_zone.present? && checkout_zone.country_list.any?
+                               checkout_zone.country_list.first
+                             else
+                               Country.find_by(iso: 'US') || Country.first
+                             end
+    end
   end
 end