spree_core 4.1.1 → 4.5.0

data/app/models/concerns/spree/memoized_data.rb

@@ -0,0 +1,24 @@
+module Spree
+  module MemoizedData
+    extend ActiveSupport::Concern
+
+    included do
+      # reset cache on save inside transaction and transaction commit
+      after_save :reset_memoized_data
+      after_commit :reset_memoized_data
+
+      def reload(options = {})
+        reset_memoized_data
+        super(options)
+      end
+
+      private
+
+      def reset_memoized_data
+        self.class.const_get('MEMOIZED_METHODS').each do |v|
+          instance_variable_set(:"@#{v.gsub(/\?/, '')}", nil)
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/metadata.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Metadata
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :public_metadata, default: {}
+      attribute :private_metadata, default: {}
+      serialize :public_metadata, HashSerializer
+      serialize :private_metadata, HashSerializer
+    end
+
+    # https://nandovieira.com/using-postgresql-and-jsonb-with-ruby-on-rails
+    class HashSerializer
+      def self.dump(hash)
+        hash
+      end
+
+      def self.load(hash)
+        (hash || {}).with_indifferent_access
+      end
+    end
+  end
+end

data/app/models/concerns/spree/multi_store_resource.rb

@@ -0,0 +1,24 @@
+module Spree
+  module MultiStoreResource
+    extend ActiveSupport::Concern
+
+    included do
+      scope :for_store, ->(store) { joins(:stores).where(Store.table_name => { id: store.id }) }
+
+      validate :must_have_one_store, unless: :disable_store_presence_validation?
+    end
+
+    protected
+
+    def must_have_one_store
+      return if stores.any?
+
+      errors.add(:stores, Spree.t(:must_have_one_store))
+    end
+
+    # this can be overridden on model basis
+    def disable_store_presence_validation?
+      Spree::Config[:disable_store_presence_validation]
+    end
+  end
+end

data/app/models/concerns/spree/named_type.rb

@@ -6,7 +6,7 @@ module Spree
       scope :active, -> { where(active: true) }
       default_scope { order(Arel.sql("LOWER(#{table_name}.name)")) }
 
-      validates :name, presence: true, uniqueness: { case_sensitive: false }
+      include UniqueName
     end
   end
 end

data/app/models/concerns/spree/number_identifier.rb

@@ -0,0 +1,18 @@
+module Spree
+  module NumberIdentifier
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :uppercase_number
+
+      validates :number, presence: true, length: { maximum: 32, allow_blank: true },
+                         uniqueness: { allow_blank: true, case_sensitive: true, scope: spree_base_uniqueness_scope }
+    end
+
+    protected
+
+    def uppercase_number
+      number&.to_s&.upcase!
+    end
+  end
+end

data/app/models/concerns/spree/product_scopes.rb

@@ -27,39 +27,56 @@ module Spree
           next if name.to_s.include?('master_price')
 
           parts = name.to_s.match(/(.*)_by_(.*)/)
-          scope(name.to_s, -> { order(Arel.sql("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ? 'ASC' : 'DESC'}")) })
+          scope(name.to_s, -> { order(Arel.sql(sanitize_sql("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ? 'ASC' : 'DESC'}"))) })
         end
       end
 
       def self.property_conditions(property)
         properties = Property.table_name
         case property
-        when String   then { "#{properties}.name" => property }
         when Property then { "#{properties}.id" => property.id }
-        else { "#{properties}.id" => property.to_i }
+        when Integer  then { "#{properties}.id" => property }
+        else
+          if Property.column_for_attribute('id').type == :uuid
+            ["#{properties.name} = ? OR #{properties.id} = ?", property, property]
+          else
+            { "#{properties}.name" => property }
+          end
         end
       end
 
       add_simple_scopes simple_scopes
 
       add_search_scope :ascend_by_master_price do
-        joins(master: :default_price).order("#{price_table_name}.amount ASC")
+        order("#{price_table_name}.amount ASC")
       end
 
       add_search_scope :descend_by_master_price do
-        joins(master: :default_price).order("#{price_table_name}.amount DESC")
+        order("#{price_table_name}.amount DESC")
       end
 
       add_search_scope :price_between do |low, high|
-        joins(master: :default_price).where(Price.table_name => { amount: low..high })
+        where(Price.table_name => { amount: low..high })
       end
 
       add_search_scope :master_price_lte do |price|
-        joins(master: :default_price).where("#{price_table_name}.amount <= ?", price)
+        where("#{price_table_name}.amount <= ?", price)
       end
 
       add_search_scope :master_price_gte do |price|
-        joins(master: :default_price).where("#{price_table_name}.amount >= ?", price)
+        where("#{price_table_name}.amount >= ?", price)
+      end
+
+      add_search_scope :in_stock do
+        joins(:variants_including_master).merge(Spree::Variant.in_stock)
+      end
+
+      add_search_scope :backorderable do
+        joins(:variants_including_master).merge(Spree::Variant.backorderable)
+      end
+
+      add_search_scope :in_stock_or_backorderable do
+        joins(:variants_including_master).merge(Spree::Variant.in_stock_or_backorderable)
       end
 
       # This scope selects products in taxon AND all its descendants
@@ -81,7 +98,7 @@ module Spree
       #   SELECT COUNT(*) ...
       add_search_scope :in_taxon do |taxon|
         includes(:classifications).
-          where('spree_products_taxons.taxon_id' => taxon.self_and_descendants.pluck(:id)).
+          where('spree_products_taxons.taxon_id' => taxon.cached_self_and_descendants_ids).
           order('spree_products_taxons.position ASC')
       end
 
@@ -94,6 +111,19 @@ module Spree
         taxons.first ? prepare_taxon_conditions(taxons) : where(nil)
       end
 
+      add_search_scope :ascend_by_taxons_min_position do |taxon_ids|
+        joins(:classifications).
+          where(Classification.table_name => { taxon_id: taxon_ids }).
+          select(
+            [
+              "#{Product.table_name}.*",
+              "MIN(#{Classification.table_name}.position) AS min_position"
+            ].join(', ')
+          ).
+          group(:id).
+          order(min_position: :asc)
+      end
+
       # a scope that finds all products having property specified by name, object or id
       add_search_scope :with_property do |property|
         joins(:properties).where(property_conditions(property))
@@ -107,27 +137,41 @@ module Spree
           where(property_conditions(property))
       end
 
-      add_search_scope :with_option do |option|
-        option_types = OptionType.table_name
-        conditions = case option
-                     when String     then { "#{option_types}.name" => option }
-                     when OptionType then { "#{option_types}.id" => option.id }
-                     else { "#{option_types}.id" => option.to_i }
-                     end
+      add_search_scope :with_property_values do |property_filter_param, property_values|
+        joins(product_properties: :property).
+          where(Property.table_name => { filter_param: property_filter_param }).
+          where(ProductProperty.table_name => { filter_param: property_values.map(&:parameterize) })
+      end
 
-        joins(:option_types).where(conditions)
+      add_search_scope :with_option do |option|
+        if option.is_a?(OptionType)
+          joins(:option_types).where(spree_option_types: { id: option.id })
+        elsif option.is_a?(Integer)
+          joins(:option_types).where(spree_option_types: { id: option })
+        elsif OptionType.column_for_attribute('id').type == :uuid
+          joins(:option_types).where(spree_option_types: { name: option }).or(Product.joins(:option_types).where(spree_option_types: { id: option }))
+        else
+          joins(:option_types).where(spree_option_types: { name: option })
+        end
       end
 
       add_search_scope :with_option_value do |option, value|
-        option_values = OptionValue.table_name
         option_type_id = case option
-                         when String then OptionType.find_by(name: option) || option.to_i
                          when OptionType then option.id
-                         else option.to_i
+                         when Integer then option
+                         else
+                           if OptionType.column_for_attribute('id').type == :uuid
+                             OptionType.where(id: option).or(OptionType.where(name: option))&.first&.id
+                           else
+                             OptionType.where(name: option)&.first&.id
+                           end
                          end
 
-        conditions = "#{option_values}.name = ? AND #{option_values}.option_type_id = ?", value, option_type_id
-        group('spree_products.id').joins(variants_including_master: :option_values).where(conditions)
+        return Product.group("#{Spree::Product.table_name}.id").none if option_type_id.blank?
+
+        group("#{Spree::Product.table_name}.id").
+          joins(variants_including_master: :option_values).
+          where(Spree::OptionValue.table_name => { name: value, option_type_id: option_type_id })
       end
 
       # Finds all products which have either:
@@ -192,16 +236,35 @@ module Spree
 
       def self.not_discontinued(only_not_discontinued = true)
         if only_not_discontinued != '0' && only_not_discontinued
-          where("#{Product.quoted_table_name}.discontinue_on IS NULL or #{Product.quoted_table_name}.discontinue_on >= ?", Time.zone.now)
+          where.not(status: 'archived')
         else
           all
         end
       end
       search_scopes << :not_discontinued
+
+      def self.with_currency(currency)
+        joins(variants_including_master: :prices).
+          where(Price.table_name => { currency: currency.upcase }).
+          where.not(Price.table_name => { amount: nil }).
+          distinct
+      end
+      search_scopes << :with_currency
+
       # Can't use add_search_scope for this as it needs a default argument
-      def self.available(available_on = nil, _currency = nil)
-        available_on ||= Time.current
-        not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on)
+      def self.available(available_on = nil, currency = nil)
+        if available_on
+          scope = not_discontinued.where("#{Product.quoted_table_name}.available_on <= ?", available_on)
+        else
+          scope = where(status: 'active')
+        end
+
+        unless Spree::Config.show_products_without_price
+          currency ||= Spree::Store.default.default_currency
+          scope = scope.with_currency(currency)
+        end
+
+        scope
       end
       search_scopes << :available
 
@@ -210,10 +273,45 @@ module Spree
       end
       search_scopes << :active
 
+      def self.for_filters(currency, taxon: nil)
+        scope = active(currency)
+        scope = scope.in_taxon(taxon) if taxon.present?
+        scope
+      end
+      search_scopes << :for_filters
+
+      def self.for_user(user = nil)
+        if user.try(:has_spree_role?, 'admin')
+          with_deleted
+        else
+          not_deleted.where(status: 'active')
+        end
+      end
+
       add_search_scope :taxons_name_eq do |name|
         group('spree_products.id').joins(:taxons).where(Taxon.arel_table[:name].eq(name))
       end
 
+      # .search_by_name
+      if defined?(PgSearch)
+        include PgSearch::Model
+
+        if defined?(SpreeGlobalize)
+          pg_search_scope :search_by_name, associated_against: { translations: :name }, using: { tsearch: { any_word: true, prefix: true } }
+        else
+          pg_search_scope :search_by_name, against: :name, using: { tsearch: { any_word: true, prefix: true } }
+        end
+      else
+        def self.search_by_name(query)
+          if defined?(SpreeGlobalize)
+            joins(:translations).order(:name).where("LOWER(#{Product::Translation.table_name}.name) LIKE LOWER(:query)", query: "%#{query}%").distinct
+          else
+            where("LOWER(#{Product.table_name}.name) LIKE LOWER(:query)", query: "%#{query}%")
+          end
+        end
+      end
+      search_scopes << :search_by_name
+
       def self.price_table_name
         Price.quoted_table_name
       end
@@ -221,7 +319,7 @@ module Spree
 
       # specifically avoid having an order for taxon search (conflicts with main order)
       def self.prepare_taxon_conditions(taxons)
-        ids = taxons.map { |taxon| taxon.self_and_descendants.pluck(:id) }.flatten.uniq
+        ids = taxons.map(&:cached_self_and_descendants_ids).flatten.uniq
         joins(:classifications).where(Classification.table_name => { taxon_id: ids })
       end
       private_class_method :prepare_taxon_conditions
@@ -237,14 +335,11 @@ module Spree
       private_class_method :prepare_words
 
       def self.get_taxons(*ids_or_records_or_names)
-        taxons = Taxon.table_name
         ids_or_records_or_names.flatten.map do |t|
           case t
-          when Integer then Taxon.find_by(id: t)
           when ApplicationRecord then t
-          when String
-            Taxon.find_by(name: t) ||
-              Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
+          else
+            Taxon.where(Taxon.arel_table[:name].eq(t)).or(Taxon.where(Taxon.arel_table[:id].eq(t))).or(Taxon.where(Taxon.arel_table[:permalink].matches("%/#{t}/"))).or(Taxon.where(Taxon.arel_table[:permalink].matches("#{t}/"))).first
           end
         end.compact.flatten.uniq
       end

data/app/models/concerns/spree/single_store_resource.rb

@@ -0,0 +1,19 @@
+module Spree
+  module SingleStoreResource
+    extend ActiveSupport::Concern
+
+    included do
+      validate :ensure_store_association_is_not_changed
+
+      scope :for_store, ->(store) { where(store_id: store.id) }
+    end
+
+    protected
+
+    def ensure_store_association_is_not_changed
+      if store_id_changed? && persisted?
+        errors.add(:store, Spree.t('errors.messages.store_association_can_not_be_changed'))
+      end
+    end
+  end
+end

data/app/models/concerns/spree/unique_name.rb

@@ -0,0 +1,10 @@
+module Spree
+  module UniqueName
+    extend ActiveSupport::Concern
+
+    included do
+      validates :name, presence: true,
+                       uniqueness: { case_sensitive: false, allow_blank: true, scope: spree_base_uniqueness_scope }
+    end
+  end
+end

data/app/models/concerns/spree/user_address.rb

@@ -16,7 +16,12 @@ module Spree
       has_many :addresses, -> { where(deleted_at: nil).order('updated_at DESC') },
                            class_name: 'Spree::Address', foreign_key: :user_id
 
+      validate :address_not_associated_with_other_user, :address_not_deprecated_in_completed_order
+
       def persist_order_address(order)
+        # FIXME: we should check if the User's address is associated with country accepted by Store
+        # if not we should try to find an address with valid country in User's address book
+        # or we should call `build_bill_address`
         b_address = bill_address || build_bill_address
         b_address.attributes = order.bill_address.value_attributes
         b_address.save
@@ -30,6 +35,20 @@ module Spree
           update(ship_address_id: s_address.id)
         end
       end
+
+      private
+
+      def address_not_associated_with_other_user
+        errors.add(:bill_address_id, :belongs_to_other_user) if bill_address&.user_id && self != bill_address&.user
+        errors.add(:ship_address_id, :belongs_to_other_user) if ship_address&.user_id && self != ship_address&.user
+      end
+
+      def address_not_deprecated_in_completed_order
+        errors.add(:bill_address_id, :deprecated_in_completed_order) if
+          orders.complete.with_deleted_bill_address.where(bill_address: bill_address_id).any?
+        errors.add(:ship_address_id, :deprecated_in_completed_order) if
+          orders.complete.with_deleted_ship_address.where(ship_address: ship_address_id).any?
+      end
     end
   end
 end

data/app/models/concerns/spree/user_methods.rb

@@ -4,6 +4,7 @@ module Spree
 
     include Spree::UserPaymentSource
     include Spree::UserReporting
+    include Spree::UserRoles
     include Spree::RansackableAttributes
 
     included do
@@ -15,9 +16,6 @@ module Spree
 
       attr_accessor :use_billing
 
-      has_many :role_users, class_name: 'Spree::RoleUser', foreign_key: :user_id, dependent: :destroy
-      has_many :spree_roles, through: :role_users, class_name: 'Spree::Role', source: :role
-
       has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser', foreign_key: :user_id, dependent: :destroy
       has_many :promotion_rules, through: :promotion_rule_users, class_name: 'Spree::PromotionRule'
 
@@ -27,26 +25,28 @@ module Spree
       belongs_to :ship_address, class_name: 'Spree::Address', optional: true
       belongs_to :bill_address, class_name: 'Spree::Address', optional: true
 
-      self.whitelisted_ransackable_associations = %w[bill_address ship_address]
+      has_many :wishlists, class_name: 'Spree::Wishlist', foreign_key: :user_id
+
+      self.whitelisted_ransackable_associations = %w[bill_address ship_address addresses]
       self.whitelisted_ransackable_attributes = %w[id email]
 
+      def self.with_email(query)
+        where("#{table_name}.email LIKE ?", "%#{query}%")
+      end
+
       def self.with_address(query, address = :ship_address)
         left_outer_joins(address).
           where("#{Spree::Address.table_name}.firstname like ?", "%#{query}%").
           or(left_outer_joins(address).where("#{Spree::Address.table_name}.lastname like ?", "%#{query}%"))
       end
 
-      def self.with_email_or_addresses_ids(query, addresses_ids = [])
-        where('email LIKE ?', "%#{query}%").
-          or(where(id: addresses_ids))
+      def self.with_email_or_address(email, address)
+        left_outer_joins(:addresses).
+          where("#{Spree::Address.table_name}.firstname LIKE ? or #{Spree::Address.table_name}.lastname LIKE ? or #{table_name}.email LIKE ?",
+                "%#{address}%", "%#{address}%", "%#{email}%")
       end
     end
 
-    # has_spree_role? simply needs to return true or false whether a user has a role or not.
-    def has_spree_role?(role_in_question)
-      spree_roles.any? { |role| role.name == role_in_question.to_s }
-    end
-
     def last_incomplete_spree_order(store, options = {})
       orders.where(store: store).incomplete.
         includes(options[:includes]).
@@ -54,8 +54,25 @@ module Spree
         first
     end
 
-    def total_available_store_credit
-      store_credits.reload.to_a.sum(&:amount_remaining)
+    def total_available_store_credit(currency = nil, store = nil)
+      store ||= Store.default
+      currency ||= store.default_currency
+      store_credits.for_store(store).where(currency: currency).reload.to_a.sum(&:amount_remaining)
+    end
+
+    def available_store_credits(store)
+      store ||= Store.default
+
+      store_credits.for_store(store).pluck(:currency).uniq.each_with_object([]) do |currency, arr|
+        arr << Spree::Money.new(total_available_store_credit(currency, store), currency: currency)
+      end
+    end
+
+    def default_wishlist_for_store(current_store)
+      wishlists.find_or_create_by(is_default: true, store_id: current_store.id) do |wishlist|
+        wishlist.name = Spree.t(:default_wishlist_name)
+        wishlist.save
+      end
     end
 
     private

data/app/models/concerns/spree/user_payment_source.rb

@@ -9,7 +9,7 @@ module Spree
       end
 
       def payment_sources
-        credit_cards.with_payment_profile
+        credit_cards.with_payment_profile.not_expired.where(payment_method: Spree::PaymentMethod.active).not_removed
       end
 
       def drop_payment_source(source)

data/app/models/concerns/spree/user_reporting.rb

@@ -3,20 +3,45 @@ module Spree
     extend DisplayMoney
     money_methods :lifetime_value, :average_order_value
 
-    def lifetime_value
-      orders.complete.sum(:total)
+    def report_values_for(report_name, store)
+      store ||= Store.default
+
+      completed_orders(store).pluck(:currency).uniq.each_with_object([]) do |currency, arr|
+        arr << send("display_#{report_name}", store: store, currency: currency)
+      end
     end
 
-    def order_count
-      orders.complete.size
+    def lifetime_value(**args)
+      order_calculate(operation: :sum,
+                      column: :total,
+                      **args)
     end
 
-    def average_order_value
-      if order_count > 0
-        lifetime_value / order_count
-      else
-        BigDecimal('0.00')
-      end
+    def average_order_value(**args)
+      order_calculate(operation: :average,
+                      column: :total,
+                      **args)
+    end
+
+    def order_count(store = nil)
+      store ||= Store.default
+      order_calculate(store: store,
+                      currency: store.supported_currencies.split(','),
+                      operation: :count,
+                      column: :all)
+    end
+
+    private
+
+    def order_calculate(operation:, column:, store: nil, currency: nil)
+      store ||= Store.default
+      currency ||= store.default_currency
+
+      completed_orders(store).where(currency: currency).calculate(operation, column) || BigDecimal('0.00')
+    end
+
+    def completed_orders(store)
+      orders.for_store(store).complete.order(currency: :desc)
     end
   end
 end

data/app/models/concerns/spree/user_roles.rb

@@ -0,0 +1,43 @@
+module Spree
+  module UserRoles
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :role_users, class_name: 'Spree::RoleUser', foreign_key: :user_id, dependent: :destroy
+      has_many :spree_roles, through: :role_users, class_name: 'Spree::Role', source: :role
+
+      scope :spree_admin, -> { joins(:spree_roles).where(Spree::Role.table_name => { name: 'admin' }) }
+
+      # has_spree_role? simply needs to return true or false whether a user has a role or not.
+      def has_spree_role?(role_name)
+        spree_roles.exists?(name: role_name)
+      end
+
+      def self.admin
+        ActiveSupport::Deprecation.warn('`User#admin` is deprecated and will be removed in Spree 5. Please use `User#spree_admin`')
+
+        spree_admin
+      end
+
+      def self.admin_created?
+        ActiveSupport::Deprecation.warn('`User#admin_created?` is deprecated and will be removed in Spree 5. Please use `User#spree_admin_created?`')
+
+        spree_admin_created?
+      end
+
+      def admin?
+        ActiveSupport::Deprecation.warn('`User#admin?` is deprecated and will be removed in Spree 5. Please use `User#spree_admin?`')
+
+        spree_admin?
+      end
+
+      def self.spree_admin_created?
+        spree_admin.exists?
+      end
+
+      def spree_admin?
+        has_spree_role?('admin')
+      end
+    end
+  end
+end