spree_core 4.2.7 → 4.3.0.rc1

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

data/app/models/spree/store_credit.rb

@@ -1,5 +1,7 @@
 module Spree
   class StoreCredit < Spree::Base
+    include SingleStoreResource
+
     acts_as_paranoid
 
     VOID_ACTION       = 'void'.freeze
@@ -16,9 +18,10 @@ module Spree
     belongs_to :category, class_name: 'Spree::StoreCreditCategory'
     belongs_to :created_by, class_name: Spree.user_class.to_s, foreign_key: 'created_by_id'
     belongs_to :credit_type, class_name: 'Spree::StoreCreditType', foreign_key: 'type_id'
-    has_many :store_credit_events
+    belongs_to :store, class_name: 'Spree::Store'
+    has_many :store_credit_events, class_name: 'Spree::StoreCreditEvent'
 
-    validates :user, :category, :credit_type, :created_by, :currency, presence: true
+    validates :user, :category, :credit_type, :created_by, :currency, :store, presence: true
     validates :amount, numericality: { greater_than: 0 }
     validates :amount_used, numericality: { greater_than_or_equal_to: 0 }
     validate :amount_used_less_than_or_equal_to_amount
@@ -188,7 +191,8 @@ module Spree
         created_by_id: created_by_id,
         currency: currency,
         type_id: type_id,
-        memo: credit_allocation_memo
+        memo: credit_allocation_memo,
+        store: store
       }
     end
 

data/app/models/spree/store_credit_event.rb

@@ -8,7 +8,7 @@ module Spree
     scope :exposed_events, -> { where.not(action: [Spree::StoreCredit::ELIGIBLE_ACTION, Spree::StoreCredit::AUTHORIZE_ACTION]) }
     scope :reverse_chronological, -> { order(created_at: :desc) }
 
-    delegate :currency, to: :store_credit
+    delegate :currency, :store, to: :store_credit
 
     def display_amount
       Spree::Money.new(amount, currency: currency)
@@ -32,7 +32,7 @@ module Spree
     end
 
     def order
-      Spree::Payment.find_by(response_code: authorization_code).try(:order)
+      store.payments.find_by(response_code: authorization_code).try(:order)
     end
   end
 end

data/app/models/spree/store_payment_method.rb

@@ -0,0 +1,11 @@
+module Spree
+  class StorePaymentMethod < Spree::Base
+    self.table_name = 'spree_payment_methods_stores'
+
+    belongs_to :store, class_name: 'Spree::Store', touch: true
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', touch: true
+
+    validates :store, :payment_method, presence: true
+    validates :store_id, uniqueness: { scope: :payment_method_id }
+  end
+end

data/app/models/spree/store_product.rb

@@ -0,0 +1,11 @@
+module Spree
+  class StoreProduct < Spree::Base
+    self.table_name = 'spree_products_stores'
+
+    belongs_to :store, class_name: 'Spree::Store', touch: true
+    belongs_to :product, class_name: 'Spree::Product', touch: true
+
+    validates :store, :product, presence: true
+    validates :store_id, uniqueness: { scope: :product_id }
+  end
+end

data/app/models/spree/store_promotion.rb

@@ -0,0 +1,11 @@
+module Spree
+  class StorePromotion < Spree::Base
+    self.table_name = 'spree_promotions_stores'
+
+    belongs_to :store, class_name: 'Spree::Store', touch: true
+    belongs_to :promotion, class_name: 'Spree::Promotion', touch: true
+
+    validates :store, :promotion, presence: true
+    validates :store_id, uniqueness: { scope: :promotion_id }
+  end
+end

data/app/models/spree/taxon.rb

@@ -13,6 +13,9 @@ module Spree
     has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
     has_many :products, through: :classifications
 
+    has_many :menu_items, as: :linked_resource
+    has_many :cms_sections, as: :linked_resource
+
     has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
     has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'
 
@@ -20,23 +23,30 @@ module Spree
     has_many :promotion_rules, through: :promotion_rule_taxons, class_name: 'Spree::PromotionRule'
 
     validates :name, presence: true, uniqueness: { scope: [:parent_id, :taxonomy_id], allow_blank: true, case_sensitive: false }
-    validates :permalink, uniqueness: { case_sensitive: false }
+    validates :taxonomy, presence: true
+    validates :permalink, uniqueness: { case_sensitive: false, scope: [:parent_id, :taxonomy_id] }
     validates :hide_from_nav, inclusion: { in: [true, false] }
     validates_associated :icon
     validate :check_for_root, on: :create
+    validate :parent_belongs_to_same_taxonomy
     with_options length: { maximum: 255 }, allow_blank: true do
       validates :meta_keywords
       validates :meta_description
       validates :meta_title
     end
 
+    before_validation :copy_taxonomy_from_parent
     after_save :touch_ancestors_and_taxonomy
     after_touch :touch_ancestors_and_taxonomy
 
     has_one :icon, as: :viewable, dependent: :destroy, class_name: 'Spree::TaxonImage'
 
+    scope :for_store, ->(store) { joins(:taxonomy).where(spree_taxonomies: { store_id: store.id }) }
+
     self.whitelisted_ransackable_associations = %w[taxonomy]
 
+    scope :for_stores, ->(stores) { joins(:taxonomy).where(spree_taxonomies: { store_id: stores.ids }) }
+
     # indicate which filters should be used for a taxon
     # this method should be customized to your own site
     def applicable_filters
@@ -104,5 +114,15 @@ module Spree
         errors.add(:root_conflict, 'this taxonomy already has a root taxon')
       end
     end
+
+    def parent_belongs_to_same_taxonomy
+      if parent.present? && parent.taxonomy_id != taxonomy_id
+        errors.add(:parent, 'must belong to the same taxonomy')
+      end
+    end
+
+    def copy_taxonomy_from_parent
+      self.taxonomy = parent.taxonomy if parent.present? && taxonomy.blank?
+    end
   end
 end

data/app/models/spree/taxon_image/configuration/active_storage.rb

@@ -9,6 +9,8 @@ module Spree
 
           has_one_attached :attachment
 
+          default_scope { includes(attachment_attachment: :blob) }
+
           def self.styles
             @styles ||= {
               mini: '32x32>',

data/app/models/spree/taxonomy.rb

@@ -2,10 +2,12 @@ module Spree
   class Taxonomy < Spree::Base
     acts_as_list
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true, scope: :store_id }
+    validates :store, presence: true
 
     has_many :taxons, inverse_of: :taxonomy
     has_one :root, -> { where parent_id: nil }, class_name: 'Spree::Taxon', dependent: :destroy
+    belongs_to :store, class_name: 'Spree::Store'
 
     after_create :set_root
     after_save :set_root_taxon_name

data/app/models/spree/variant.rb

@@ -3,6 +3,10 @@ module Spree
     acts_as_paranoid
     acts_as_list scope: :product
 
+    include MemoizedData
+
+    MEMOIZED_METHODS = %w(purchasable in_stock backorderable tax_category options_text compare_at_price)
+
     belongs_to :product, -> { with_deleted }, touch: true, class_name: 'Spree::Product', inverse_of: :variants
     belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
 
@@ -29,7 +33,7 @@ module Spree
     end
 
     has_many :option_value_variants, class_name: 'Spree::OptionValueVariant'
-    has_many :option_values, through: :option_value_variants, class_name: 'Spree::OptionValue'
+    has_many :option_values, through: :option_value_variants, dependent: :destroy, class_name: 'Spree::OptionValue'
 
     has_many :images, -> { order(:position) }, as: :viewable, dependent: :destroy, class_name: 'Spree::Image'
 
@@ -93,6 +97,7 @@ module Spree
       not_discontinued.not_deleted.
         for_currency_and_available_price_amount(currency)
     end
+    # FIXME: cost price should be represented with DisplayMoney class
     LOCALIZED_NUMBERS = %w(cost_price weight depth width height)
 
     LOCALIZED_NUMBERS.each do |m|
@@ -199,6 +204,10 @@ module Spree
       price_in(currency).try(:amount)
     end
 
+    def compare_at_amount_in(currency)
+      price_in(currency).try(:compare_at_amount)
+    end
+
     def price_modifier_amount_in(currency, options = {})
       return 0 unless options.present?
 
@@ -242,7 +251,7 @@ module Spree
       # Check if model responds to cache version and fall back to updated_at for older rails versions
       # This makes sure a version is supplied when recyclable cache keys are disabled.
       version = respond_to?(:cache_version) ? cache_version : updated_at.to_i
-      Rails.cache.fetch(in_stock_cache_key, version: version) do
+      @in_stock ||= Rails.cache.fetch(in_stock_cache_key, version: version) do
         total_on_hand > 0
       end
     end
@@ -252,7 +261,7 @@ module Spree
     alias is_backorderable? backorderable?
 
     def purchasable?
-      in_stock? || backorderable?
+      @purchasable ||= in_stock? || backorderable?
     end
 
     # Shortcut method to determine if inventory tracking is enabled for this variant
@@ -282,7 +291,7 @@ module Spree
     end
 
     def backordered?
-      total_on_hand <= 0 && stock_items.exists?(backorderable: true)
+      @backordered ||= total_on_hand <= 0 && stock_items.exists?(backorderable: true)
     end
 
     private

data/app/presenters/spree/filters/options_presenter.rb

@@ -0,0 +1,27 @@
+module Spree
+  module Filters
+    class OptionsPresenter
+      FilterableOptionType = Struct.new(:option_type, :option_values, keyword_init: true) do
+        delegate_missing_to :option_type
+      end
+
+      def initialize(option_values_scope:)
+        @option_values = option_values_scope.includes(:option_type)
+      end
+
+      def to_a
+        grouped_options.map do |option_type, option_values|
+          FilterableOptionType.new(option_type: option_type, option_values: option_values)
+        end
+      end
+
+      private
+
+      attr_reader :option_values
+
+      def grouped_options
+        option_values.group_by(&:option_type)
+      end
+    end
+  end
+end

data/app/presenters/spree/filters/price_presenter.rb

@@ -0,0 +1,22 @@
+module Spree
+  module Filters
+    class PricePresenter
+      def initialize(amount:, currency:)
+        @amount = amount.to_i
+        @currency = currency
+      end
+
+      def to_i
+        amount
+      end
+
+      def to_s
+        Spree::Money.new(amount, currency: currency, no_cents_if_whole: true).to_s
+      end
+
+      private
+
+      attr_reader :amount, :currency
+    end
+  end
+end

data/app/presenters/spree/filters/price_range_presenter.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Filters
+    class PriceRangePresenter
+      def self.from_param(param, currency:)
+        prices = param.split('-')
+
+        new(
+          min_price: PricePresenter.new(amount: prices.first, currency: currency),
+          max_price: PricePresenter.new(amount: prices.last, currency: currency)
+        )
+      end
+
+      def initialize(min_price:, max_price:)
+        @min_price = min_price
+        @max_price = max_price
+      end
+
+      attr_reader :min_price, :max_price
+
+      def to_param
+        "#{min_price.to_i}-#{max_price.to_i}"
+      end
+
+      def to_s
+        "#{min_price} - #{max_price}"
+      end
+    end
+  end
+end