spree_core 4.0.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5c784614a14ca9019dd8effe620628917a726c4b173302a4e96a11cd8dde241
-  data.tar.gz: d50f4eefd34a384068ccb6eb814badec4e0cc829b52785bcafea37caa09e335a
+  metadata.gz: 619f5416fb099c1cccaeb2432fd6002b53aa605aff90c9b4078f2a51ba73e89b
+  data.tar.gz: e53a5c780f9c4e79c50cc38d2fdd055dc20b04bef93c89e33e88b7a4fd9facce
 SHA512:
-  metadata.gz: 43b7df9743323b445496eb6ca7f8d326ef5f28c01d258455d61ccfcdfcf7ade994ba11fe5fca6bb8a83010f0fd571d40f6514adc416e0aab7332fd93be3d4916
-  data.tar.gz: c98509b281dd94ed9bcf13ffdc19bbdc54ac38c3e0027b93b28305f041522d12d23d77cd8cf5299084d7eb8f0b723803d4c1e2aa025299248f37409354f4b77f
+  metadata.gz: 7e8cc84789a7c8564b45576c2aa9f8974f62da3b2c752869a9950497b01382b073b50a4d7746d9f2142bee4248115b58a527637b104f3750504499f2a6608459
+  data.tar.gz: fab84d0b2eb02221f96209f11c118feb77928d69269b009abb4c9a773089f1a011a96bbb3b731abce9cd8af45208eaabdef464c27244b7fd954554de1203c15b

data/app/controllers/spree/base_controller.rb

@@ -7,8 +7,8 @@ class Spree::BaseController < ApplicationController
   include Spree::Core::ControllerHelpers::Search
   include Spree::Core::ControllerHelpers::Store
   include Spree::Core::ControllerHelpers::StrongParameters
+  include Spree::Core::ControllerHelpers::Locale
+  include Spree::Core::ControllerHelpers::Currency
 
   respond_to :html
 end
-
-require 'spree/i18n/initializer'

data/app/finders/concerns/spree/product_filterable.rb

@@ -0,0 +1,9 @@
+module Spree
+  module ProductFilterable
+    private
+
+    def find_available(scope, products_scope)
+      scope.filterable.for_products(products_scope)
+    end
+  end
+end

data/app/finders/spree/addresses/find.rb

@@ -0,0 +1,6 @@
+module Spree
+  module Addresses
+    class Find < ::Spree::BaseFinder
+    end
+  end
+end

data/app/finders/spree/base_finder.rb

@@ -0,0 +1,14 @@
+module Spree
+  class BaseFinder
+    def initialize(scope:, params:)
+      @scope = scope
+      @params = params
+    end
+
+    attr_reader :scope, :params
+
+    def execute
+      scope
+    end
+  end
+end

data/app/finders/spree/cms_pages/find.rb

@@ -0,0 +1,41 @@
+module Spree
+  module CmsPages
+    class Find < ::Spree::BaseFinder
+      ALLOWED_KINDS = %w[standard home feature].freeze
+
+      def initialize(scope:, params:)
+        @scope = scope
+        @title = params.dig(:filter, :title)
+        @kind  = params.dig(:filter, :type)
+      end
+
+      def execute
+        pages = by_title(scope)
+        pages = by_kind(pages)
+
+        pages
+      end
+
+      private
+
+      attr_reader :scope, :title, :kind
+
+      def title_matcher
+        Spree::CmsPage.arel_table[:title].matches("%#{title}%")
+      end
+
+      def by_title(pages)
+        return pages if title.blank?
+
+        pages.where(title_matcher)
+      end
+
+      def by_kind(pages)
+        return pages if kind.blank?
+        return pages if ALLOWED_KINDS.exclude?(kind)
+
+        pages.send(kind)
+      end
+    end
+  end
+end

data/app/finders/spree/countries/find.rb

@@ -1,13 +1,21 @@
 module Spree
   module Countries
-    class Find
-      def initialize(scope, params)
+    class Find < ::Spree::BaseFinder
+      def initialize(scope:, params:)
         @scope = scope
 
         @shippable = String(params[:filter][:shippable]) unless params[:filter].nil?
       end
 
       def call
+        ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+          Spree::Countries::Find.new.call is deprecated and will be removed in Spree 5.0.
+          Please use Spree::Countries::Find.new.execute instead
+        DEPRECATION
+        execute
+      end
+
+      def execute
         countries = by_shippability(scope)
 
         countries
@@ -15,7 +23,7 @@ module Spree
 
       private
 
-      attr_reader :shippable, :scope
+      attr_reader :shippable
 
       def shippable?
         shippable.present?

data/app/finders/spree/credit_cards/find.rb

@@ -1,7 +1,7 @@
 module Spree
   module CreditCards
-    class Find
-      def execute(scope:, params:)
+    class Find < ::Spree::BaseFinder
+      def execute
         return scope.default.take if params[:id].eql?('default')
         return scope.where(payment_method_id: params[:filter]['payment_method_id']) if params[:filter].present?
 

data/app/finders/spree/menus/find.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Menus
+    class Find < ::Spree::BaseFinder
+      def execute
+        return scope.where(location: params[:filter]['location']) if params[:filter].present? && params[:filter]['location'].present?
+
+        scope
+      end
+    end
+  end
+end

data/app/finders/spree/option_values/find_available.rb

@@ -0,0 +1,28 @@
+module Spree
+  module OptionValues
+    class FindAvailable
+      include ProductFilterable
+
+      def initialize(scope: OptionValue.spree_base_scopes, products_scope: Product.spree_base_scopes)
+        @scope = scope
+        @products_scope = products_scope
+      end
+
+      def execute
+        find_available(scope, products_scope).includes(:translations).select(select_args).order(order_args)
+      end
+
+      private
+
+      attr_reader :scope, :products_scope
+
+      def select_args
+        "#{OptionValue.table_name}.*, #{OptionType.table_name}.position AS option_type_position"
+      end
+
+      def order_args
+        "option_type_position, #{OptionValue.table_name}.position"
+      end
+    end
+  end
+end

data/app/finders/spree/orders/find_complete.rb

@@ -1,18 +1,20 @@
 module Spree
   module Orders
     class FindComplete
-      attr_reader :user, :number, :token
+      attr_reader :user, :number, :token, :store
 
-      def initialize(user: nil, number: nil, token: nil)
+      def initialize(user: nil, number: nil, token: nil, store: nil)
         @user = user
         @number = number
         @token = token
+        @store = store
       end
 
       def execute
         orders = by_user(scope)
         orders = by_number(orders)
         orders = by_token(orders)
+        orders = by_store(orders)
 
         orders
       end
@@ -35,6 +37,10 @@ module Spree
         token.present?
       end
 
+      def store?
+        store.present?
+      end
+
       def by_user(orders)
         return orders unless user?
 
@@ -53,6 +59,12 @@ module Spree
         orders.where(token: token)
       end
 
+      def by_store(orders)
+        return orders unless store?
+
+        orders.where(store: store)
+      end
+
       def scope_includes
         {
           line_items: [

data/app/finders/spree/orders/find_current.rb

@@ -9,25 +9,13 @@ module Spree
         return order unless order.nil?
         return if user.nil?
 
-        incomplete_orders.order(created_at: :desc).find_by(store: store, user: user)
+        incomplete_orders.order(created_at: :desc).find_by(store: store, user: user, currency: params[:currency])
       end
 
       private
 
       def incomplete_orders
-        Spree::Order.incomplete.includes(scope_includes)
-      end
-
-      def scope_includes
-        {
-          line_items: [
-            variant: [
-              :images,
-              option_values: :option_type,
-              product: :product_properties,
-            ]
-          ]
-        }
+        Spree::Order.incomplete.not_canceled
       end
     end
   end

data/app/finders/spree/product_properties/find_available.rb

@@ -0,0 +1,20 @@
+module Spree
+  module ProductProperties
+    class FindAvailable
+      include ProductFilterable
+
+      def initialize(scope: ProductProperty.spree_base_scopes, products_scope: Product.spree_base_scopes)
+        @scope = scope
+        @products_scope = products_scope
+      end
+
+      def execute
+        find_available(scope, products_scope).includes(:translations)
+      end
+
+      private
+
+      attr_reader :scope, :products_scope
+    end
+  end
+end

data/app/finders/spree/products/find.rb

@@ -1,40 +1,60 @@
 module Spree
   module Products
     class Find
-      def initialize(scope:, params:, current_currency:)
+      def initialize(scope:, params:, current_currency: nil)
         @scope = scope
 
+        if current_currency.present?
+          ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+            `current_currency` param is deprecated and will be removed in Spree 5.
+            Please pass `:currency` in `params` hash instead.
+          DEPRECATION
+        end
+
         @ids              = String(params.dig(:filter, :ids)).split(',')
         @skus             = String(params.dig(:filter, :skus)).split(',')
-        @price            = String(params.dig(:filter, :price)).split(',').map(&:to_f)
-        @currency         = params[:currency] || current_currency
-        @taxons           = String(params.dig(:filter, :taxons)).split(',')
+        @store            = params[:store] || Spree::Store.default
+        @price            = map_prices(String(params.dig(:filter, :price)).split(','))
+        @currency         = current_currency || params.dig(:filter, :currency) || params[:currency]
+        @taxons           = taxon_ids(params.dig(:filter, :taxons))
+        @concat_taxons    = taxon_ids(params.dig(:filter, :concat_taxons))
         @name             = params.dig(:filter, :name)
         @options          = params.dig(:filter, :options).try(:to_unsafe_hash)
         @option_value_ids = params.dig(:filter, :option_value_ids)
         @sort_by          = params.dig(:sort_by)
         @deleted          = params.dig(:filter, :show_deleted)
         @discontinued     = params.dig(:filter, :show_discontinued)
+        @properties       = params.dig(:filter, :properties)
+        @in_stock         = params.dig(:filter, :in_stock)
+        @backorderable    = params.dig(:filter, :backorderable)
+        @purchasable      = params.dig(:filter, :purchasable)
       end
 
       def execute
         products = by_ids(scope)
         products = by_skus(products)
         products = by_price(products)
+        products = by_currency(products)
         products = by_taxons(products)
+        products = by_concat_taxons(products)
         products = by_name(products)
         products = by_options(products)
         products = by_option_value_ids(products)
+        products = by_properties(products)
         products = include_deleted(products)
         products = include_discontinued(products)
+        products = show_only_stock(products)
+        products = show_only_backorderable(products)
+        products = show_only_purchasable(products)
         products = ordered(products)
 
-        products
+        products.distinct
       end
 
       private
 
-      attr_reader :ids, :skus, :price, :currency, :taxons, :name, :options, :option_value_ids, :scope, :sort_by, :deleted, :discontinued
+      attr_reader :ids, :skus, :price, :currency, :taxons, :concat_taxons, :name, :options, :option_value_ids, :scope,
+                  :sort_by, :deleted, :discontinued, :properties, :store, :in_stock, :backorderable, :purchasable
 
       def ids?
         ids.present?
@@ -48,10 +68,18 @@ module Spree
         price.present?
       end
 
+      def currency?
+        currency.present?
+      end
+
       def taxons?
         taxons.present?
       end
 
+      def concat_taxons?
+        concat_taxons.present?
+      end
+
       def name?
         name.present?
       end
@@ -68,8 +96,8 @@ module Spree
         sort_by.present?
       end
 
-      def name_matcher
-        Spree::Product.arel_table[:name].matches("%#{name}%")
+      def properties?
+        properties.present? && properties.values.reject(&:empty?).present?
       end
 
       def by_ids(products)
@@ -81,46 +109,96 @@ module Spree
       def by_skus(products)
         return products unless skus?
 
-        products.joins(:variants_including_master).distinct.where(spree_variants: { sku: skus })
+        products.joins(:variants_including_master).where(spree_variants: { sku: skus })
       end
 
       def by_price(products)
         return products unless price?
 
-        products.joins(master: :default_price).
-          distinct.
-          where(
-            spree_prices: {
-              amount: price.min..price.max,
-              currency: currency
-            }
-          )
+        products.price_between(price.min, price.max)
+      end
+
+      def by_currency(products)
+        return products unless currency?
+
+        products.with_currency(currency)
       end
 
       def by_taxons(products)
         return products unless taxons?
 
-        products.joins(:taxons).distinct.where(spree_taxons: { id: taxons })
+        products.joins(:classifications).where(Classification.table_name => { taxon_id: taxons })
+      end
+
+      def by_concat_taxons(products)
+        return products unless concat_taxons?
+
+        product_ids = Spree::Product.
+                      joins(:classifications).
+                      where(Classification.table_name => { taxon_id: concat_taxons }).
+                      group("#{Spree::Product.table_name}.id").
+                      having("COUNT(#{Spree::Product.table_name}.id) = ?", concat_taxons.length).
+                      ids
+
+        products.where(id: product_ids)
       end
 
       def by_name(products)
         return products unless name?
 
-        products.where(name_matcher)
+        product_name = name
+
+        # i18n mobility scope doesn't automatically get set for query blocks (Mobility issue #599) - set it explicitly
+        products.i18n { name.matches("%#{product_name}%") }
       end
 
       def by_options(products)
         return products unless options?
 
-        options.map do |key, value|
-          products.with_option_value(key, value)
-        end.inject(:&)
+        products_ids = options.map { |key, value| products.with_option_value(key, value)&.ids }.compact.uniq
+        products.where(id: products_ids.reduce(&:intersection))
       end
 
       def by_option_value_ids(products)
         return products unless option_value_ids?
 
-        products.joins(variants: :option_values).distinct.where(spree_option_values: { id: option_value_ids })
+        product_ids = Spree::Product.
+                      joins(variants: :option_values).
+                      where(spree_option_values: { id: option_value_ids }).
+                      group("#{Spree::Product.table_name}.id, #{Spree::Variant.table_name}.id").
+                      having('COUNT(spree_option_values.option_type_id) = ?', option_types_count(option_value_ids)).
+                      distinct.
+                      ids
+
+        products.where(id: product_ids)
+      end
+
+      def by_properties(products)
+        return products unless properties?
+
+        product_ids = []
+        index = 0
+
+        properties.to_unsafe_hash.each do |property_filter_param, product_properties_values|
+          next if property_filter_param.blank? || product_properties_values.empty?
+
+          values = product_properties_values.split(',').reject(&:empty?).uniq.map(&:parameterize)
+
+          next if values.empty?
+
+          ids = scope.unscope(:order, :includes).with_property_values(property_filter_param, values).ids
+          product_ids = index == 0 ? ids : product_ids & ids
+          index += 1
+        end
+
+        products.where(id: product_ids)
+      end
+
+      def option_types_count(option_value_ids)
+        Spree::OptionValue.
+          where(id: option_value_ids).
+          distinct.
+          count(:option_type_id)
       end
 
       def ordered(products)
@@ -128,13 +206,25 @@ module Spree
 
         case sort_by
         when 'default'
-          products
+          if taxons?
+            products.ascend_by_taxons_min_position(taxons)
+          else
+            products
+          end
+        when 'name-a-z'
+          # workaround for Mobility issue #596 - explicitly select fields to avoid error when selecting distinct
+          products.i18n.
+            select("#{Product.table_name}.*").select(:name).order(name: :asc)
+        when 'name-z-a'
+          # workaround for Mobility issue #596
+          products.i18n.
+            select("#{Product.table_name}.*").select(:name).order(name: :desc)
         when 'newest-first'
           products.order(available_on: :desc)
         when 'price-high-to-low'
-          products.select('spree_products.*, spree_prices.amount').reorder('').send(:descend_by_master_price)
+          order_by_price(products, :descend_by_master_price)
         when 'price-low-to-high'
-          products.select('spree_products.*, spree_prices.amount').reorder('').send(:ascend_by_master_price)
+          order_by_price(products, :ascend_by_master_price)
         end
       end
 
@@ -143,7 +233,45 @@ module Spree
       end
 
       def include_discontinued(products)
-        discontinued ? products : products.not_discontinued
+        discontinued ? products : products.active(currency)
+      end
+
+      def show_only_stock(products)
+        return products unless in_stock.to_s == 'true'
+
+        products.in_stock
+      end
+
+      def show_only_backorderable(products)
+        return products unless backorderable.to_s == 'true'
+
+        products.backorderable
+      end
+
+      def show_only_purchasable(products)
+        return products unless purchasable.to_s == 'true'
+
+        products.in_stock_or_backorderable
+      end
+
+      def map_prices(prices)
+        prices.map do |price|
+          price == 'Infinity' ? BigDecimal::INFINITY : price.to_f
+        end
+      end
+
+      def taxon_ids(taxons_ids)
+        return if taxons_ids.nil? || taxons_ids.to_s.blank?
+
+        taxons = store.taxons.where(id: taxons_ids.to_s.split(','))
+        taxons.map(&:cached_self_and_descendants_ids).flatten.compact.uniq.map(&:to_s)
+      end
+
+      def order_by_price(scope, order_type)
+        scope.
+          select("#{Product.table_name}.*, #{Spree::Price.table_name}.amount").
+          reorder('').
+          send(order_type)
       end
     end
   end

data/app/finders/spree/stores/find_current.rb

@@ -0,0 +1,24 @@
+module Spree
+  module Stores
+    class FindCurrent
+      def initialize(scope: nil, url: nil)
+        @scope = scope || Spree::Store
+        @url = url
+      end
+
+      def execute
+        by_url(scope) || scope.default
+      end
+
+      protected
+
+      attr_reader :scope, :url
+
+      def by_url(scope)
+        return if url.blank?
+
+        scope.by_url(url).first
+      end
+    end
+  end
+end

data/app/finders/spree/taxons/find.rb

@@ -3,26 +3,28 @@ module Spree
     class Find
       def initialize(scope:, params:)
         @scope = scope
-        @ids      = String(params.dig(:filter, :ids)).split(',')
-        @parent   = params.dig(:filter, :parent_id)
-        @taxonomy = params.dig(:filter, :taxonomy_id)
-        @name     = params.dig(:filter, :name)
-        @roots    = params.dig(:filter, :roots)
+        @ids              = String(params.dig(:filter, :ids)).split(',')
+        @parent           = params.dig(:filter, :parent_id)
+        @parent_permalink = params.dig(:filter, :parent_permalink)
+        @taxonomy         = params.dig(:filter, :taxonomy_id)
+        @name             = params.dig(:filter, :name)
+        @roots            = params.dig(:filter, :roots)
       end
 
       def execute
         taxons = by_ids(scope)
         taxons = by_parent(taxons)
+        taxons = by_parent_permalink(taxons)
         taxons = by_taxonomy(taxons)
         taxons = by_roots(taxons)
         taxons = by_name(taxons)
 
-        taxons
+        taxons.distinct
       end
 
       private
 
-      attr_reader :ids, :parent, :taxonomy, :roots, :name, :scope
+      attr_reader :ids, :parent, :parent_permalink, :taxonomy, :roots, :name, :scope
 
       def ids?
         ids.present?
@@ -32,6 +34,10 @@ module Spree
         parent.present?
       end
 
+      def parent_permalink?
+        parent_permalink.present?
+      end
+
       def taxonomy?
         taxonomy.present?
       end
@@ -56,6 +62,20 @@ module Spree
         taxons.where(parent_id: parent)
       end
 
+      def by_parent_permalink(taxons)
+        return taxons unless parent_permalink?
+
+        if Rails::VERSION::STRING >= '6.1'
+          taxons.joins(:parent).
+            join_translation_table(Taxon, 'parents_spree_taxons').
+            where(["#{Taxon.translation_table_alias}.permalink = ?", parent_permalink])
+        else
+          taxons.joins("INNER JOIN #{Spree::Taxon.table_name} AS parent_taxon ON parent_taxon.id = #{Spree::Taxon.table_name}.parent_id").
+            join_translation_table(Taxon, 'parent_taxon').
+            where(["#{Taxon.translation_table_alias}.permalink = ?", parent_permalink])
+        end
+      end
+
       def by_taxonomy(taxons)
         return taxons unless taxonomy?
 
@@ -71,7 +91,10 @@ module Spree
       def by_name(taxons)
         return taxons unless name?
 
-        taxons.where(name: name)
+        taxon_name = name
+
+        # i18n mobility scope doesn't automatically get set for query blocks (Mobility issue #599) - set it explicitly
+        taxons.i18n { name.matches("%#{taxon_name}%") }
       end
     end
   end