spree_core 4.10.1 → 5.0.0.rc1

data/app/models/spree/variant.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Variant < Spree::Base
+  class Variant < Spree.base_class
     acts_as_paranoid
     acts_as_list scope: :product
 
@@ -7,7 +7,10 @@ module Spree
     include Spree::Metadata
     include Spree::Variant::Webhooks
 
-    MEMOIZED_METHODS = %w(purchasable in_stock backorderable tax_category options_text compare_at_price)
+    MEMOIZED_METHODS = %w(purchasable in_stock on_sale backorderable tax_category options_text compare_at_price)
+
+    DIMENSION_UNITS = %w[mm cm in ft]
+    WEIGHT_UNITS = %w[g kg lb oz]
 
     belongs_to :product, -> { with_deleted }, touch: true, class_name: 'Spree::Product', inverse_of: :variants
     belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
@@ -55,7 +58,7 @@ module Spree
 
     validate :check_price
 
-    validates :option_values, presence: true, unless: :is_master?
+    validates :option_value_variants, presence: true, unless: :is_master?
 
     with_options numericality: { greater_than_or_equal_to: 0, allow_nil: true } do
       validates :cost_price
@@ -64,25 +67,30 @@ module Spree
     validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) }, case_sensitive: false, scope: spree_base_uniqueness_scope },
                     allow_blank: true, unless: :disable_sku_validation?
 
+    validates :dimensions_unit, inclusion: { in: DIMENSION_UNITS }, allow_blank: true
+    validates :weight_unit, inclusion: { in: WEIGHT_UNITS }, allow_blank: true
+
     after_create :create_stock_items
     after_create :set_master_out_of_stock, unless: :is_master?
+    after_commit :clear_line_items_cache, on: :update
+    after_update_commit :handle_track_inventory_change
+
+    after_commit :remove_prices_from_master_variant, on: [:create, :update], unless: :is_master?
+    after_commit :remove_stock_items_from_master_variant, on: :create, unless: :is_master?
 
     after_touch :clear_in_stock_cache
 
-    scope :in_stock, -> { joins(:stock_items).where("#{Spree::StockItem.table_name}.count_on_hand > ? OR #{Spree::Variant.table_name}.track_inventory = ?", 0, false) }
-    scope :backorderable, -> { joins(:stock_items).where(spree_stock_items: { backorderable: true }) }
+    scope :in_stock, -> { left_joins(:stock_items).where("#{Spree::StockItem.table_name}.count_on_hand > ? OR #{Spree::Variant.table_name}.track_inventory = ?", 0, false) }
+    scope :backorderable, -> { left_joins(:stock_items).where(spree_stock_items: { backorderable: true }) }
     scope :in_stock_or_backorderable, -> { in_stock.or(backorderable) }
 
     scope :eligible, -> {
       where(is_master: false).or(
         where(
-          <<-SQL
-            #{Variant.quoted_table_name}.id IN (
-              SELECT MIN(#{Variant.quoted_table_name}.id) FROM #{Variant.quoted_table_name}
-              GROUP BY #{Variant.quoted_table_name}.product_id
-              HAVING COUNT(*) = 1
-            )
-          SQL
+          product_id: Spree::Variant.
+                      select(:product_id).
+                      group(:product_id).
+                      having("COUNT(#{Spree::Variant.table_name}.id) = 1")
         )
       )
     }
@@ -99,7 +107,7 @@ module Spree
 
     scope :for_currency_and_available_price_amount, ->(currency = nil) do
       currency ||= Spree::Store.default.default_currency
-      joins(:prices).where('spree_prices.currency = ?', currency).where('spree_prices.amount IS NOT NULL').distinct
+      joins(:prices).where("#{Spree::Price.table_name}.currency = ?", currency).where("#{Spree::Price.table_name}.amount IS NOT NULL").distinct
     end
 
     scope :active, ->(currency = nil) do
@@ -114,6 +122,36 @@ module Spree
       joins(:option_values).where(Spree::OptionValue.table_name => { name: option_value, option_type_id: option_type_ids })
     }
 
+    scope :with_digital_assets, -> { joins(:digitals) }
+
+    if defined?(PgSearch)
+      include PgSearch::Model
+
+      pg_search_scope :search_by_sku, against: :sku, using: { tsearch: { prefix: true } }
+
+      pg_search_scope :search_by_sku_or_options,
+                      against: :sku,
+                      using: { tsearch: { prefix: true } },
+                      associated_against: { option_values: %i[presentation] }
+
+      pg_search_scope :search_by_name_sku_or_options, against: :sku, associated_against: {
+        product: %i[name],
+        option_values: %i[presentation]
+      }, using: { tsearch: { prefix: true } }
+
+      scope :multi_search, lambda { |query|
+        return none if query.blank? || query.length < 3
+
+        search_by_name_sku_or_options(query)
+      }
+    else
+      scope :multi_search, lambda { |query|
+        return none if query.blank? || query.length < 3
+
+        product_name_or_sku_cont(query)
+      }
+    end
+
     # FIXME: cost price should be represented with DisplayMoney class
     LOCALIZED_NUMBERS = %w(cost_price weight depth width height)
 
@@ -123,6 +161,24 @@ module Spree
       end
     end
 
+    accepts_nested_attributes_for(
+      :stock_items,
+      reject_if: ->(attributes) { attributes['stock_location_id'].blank? || attributes['count_on_hand'].blank? },
+      allow_destroy: false
+    )
+
+    accepts_nested_attributes_for(
+      :prices,
+      reject_if: ->(attributes) { attributes['currency'].blank? || attributes['amount'].blank? },
+      allow_destroy: true
+    )
+
+    accepts_nested_attributes_for(
+      :option_value_variants,
+      reject_if: ->(attributes) { attributes['option_value_id'].blank? },
+      allow_destroy: false
+    )
+
     self.whitelisted_ransackable_associations = %w[option_values product tax_category prices default_price]
     self.whitelisted_ransackable_attributes = %w[weight depth width height sku discontinue_on is_master cost_price cost_currency track_inventory deleted_at]
     self.whitelisted_ransackable_scopes = %i(product_name_or_sku_cont search_by_product_name_or_sku)
@@ -133,7 +189,9 @@ module Spree
       sku_condition = arel_table[:sku].lower.matches(query_pattern)
 
       if Spree.use_translations?
-        product_name_condition = Product.translation_table[:name].lower.matches(query_pattern)
+        translation_arel_table = Product::Translation.arel_table.alias(Product.translation_table_alias)[:name]
+        product_name_condition = translation_arel_table.lower.matches(query_pattern)
+
         joins(:product).
           join_translation_table(Product).
           where(product_name_condition.or(sku_condition))
@@ -147,6 +205,14 @@ module Spree
       product_name_or_sku_cont(query)
     end
 
+    def human_name
+      @human_name ||= option_values.
+                      joins(option_type: :product_option_types).
+                      merge(product.product_option_types).
+                      reorder('spree_product_option_types.position').
+                      pluck(:presentation).join('/')
+    end
+
     def available?
       !discontinued? && product.available?
     end
@@ -183,31 +249,61 @@ module Spree
       !!deleted_at
     end
 
+    # Returns default Image for Variant
+    # @return [Spree::Image]
+    def default_image
+      @default_image ||= if images.size.positive?
+                           images.first
+                         else
+                           product.default_image
+                         end
+    end
+
+    # Returns secondary Image for Variant
+    # @return [Spree::Image]
+    def secondary_image
+      @secondary_image ||= if images.size > 1
+                             images.second
+                           else
+                             product.secondary_image
+                           end
+    end
+
+    # Returns additional Images for Variant
+    # @return [Array<Spree::Image>]
+    def additional_images
+      @additional_images ||= (images + product.images).uniq.find_all { |image| image.id != default_image&.id }
+    end
+
     # Returns an array of hashes with the option type name, value and presentation
     # @return [Array<Hash>]
     def options
-      option_values.includes(:option_type).map do |option_value|
-        {
-          name: option_value.option_type.name,
-          value: option_value.name,
-          presentation: option_value.presentation
-        }
-      end
+      @options ||= option_values.
+                   includes(option_type: :product_option_types).
+                   merge(product.product_option_types).
+                   reorder('spree_product_option_types.position').
+                   map do |option_value|
+                     {
+                       name: option_value.option_type.name,
+                       value: option_value.name,
+                       presentation: option_value.presentation
+                     }
+                   end
     end
 
     def options=(options = {})
       options.each do |option|
         next if option[:name].blank? || option[:value].blank?
 
-        set_option_value(option[:name], option[:value])
+        set_option_value(option[:name], option[:value], option[:position])
       end
     end
 
-    def set_option_value(opt_name, opt_value)
+    def set_option_value(opt_name, opt_value, opt_type_position = nil)
       # no option values on master
       return if is_master
 
-      option_type = Spree::OptionType.where(['LOWER(name) = ?', opt_name.downcase.strip]).first_or_initialize do |o|
+      option_type = Spree::OptionType.where(name: opt_name.parameterize).first_or_initialize do |o|
         o.name = o.presentation = opt_name
         o.save!
       end
@@ -216,16 +312,21 @@ module Spree
 
       if current_value.nil?
         # then we have to check to make sure that the product has the option type
-        unless product.option_types.include? option_type
-          product.option_types << option_type
-        end
+        product_option_type = if (existing_prod_ot = product.product_option_types.find { |ot| ot.option_type_id == option_type.id })
+                                existing_prod_ot
+                              else
+                                product_option_type = product.product_option_types.new
+                                product_option_type.option_type = option_type
+                              end
+        product_option_type.position = opt_type_position if opt_type_position
+        product_option_type.save! if product_option_type.new_record? || product_option_type.changed?
       else
-        return if current_value.name.downcase.strip == opt_value.downcase.strip
+        return if current_value.name.parameterize == opt_value.parameterize
 
         option_values.delete(current_value)
       end
 
-      option_value = option_type.option_values.where(['LOWER(name) = ?', opt_value.downcase.strip]).first_or_initialize do |o|
+      option_value = option_type.option_values.where(name: opt_value.parameterize).first_or_initialize do |o|
         o.name = o.presentation = opt_value
         o.save!
       end
@@ -235,28 +336,39 @@ module Spree
     end
 
     def find_option_value(opt_name)
-      option_values.detect { |o| o.option_type.name.downcase.strip == opt_name.downcase.strip }
+      option_values.includes(:option_type).detect { |o| o.option_type.name.parameterize == opt_name.parameterize }
     end
 
-    def option_value(opt_name)
-      find_option_value(opt_name).try(:presentation)
+    def option_value(option_type)
+      if option_type.is_a?(Spree::OptionType)
+        option_values.detect { |o| o.option_type_id == option_type.id }.try(:presentation)
+      else
+        find_option_value(option_type).try(:presentation)
+      end
     end
 
     def price_in(currency)
       currency = currency&.upcase
-      find_or_build_price = lambda do
-        if prices.loaded?
-          prices.detect { |price| price.currency == currency } || prices.build(currency: currency)
-        else
-          prices.find_or_initialize_by(currency: currency)
-        end
-      end
 
-      Rails.cache.fetch("spree/prices/#{cache_key_with_version}/price_in/#{currency}") do
-        find_or_build_price.call
+      price = if prices.loaded? && prices.any?
+                prices.detect { |p| p.currency == currency }
+              else
+                prices.find_by(currency: currency)
+              end
+
+      if price.nil?
+        return Spree::Price.new(
+          currency: currency,
+          variant_id: id
+        )
       end
+
+      price
     rescue TypeError
-      find_or_build_price.call
+      Spree::Price.new(
+        currency: currency,
+        variant_id: id
+      )
     end
 
     def amount_in(currency)
@@ -306,13 +418,13 @@ module Spree
     end
 
     def in_stock?
-      # Issue 10280
-      # 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
-      @in_stock ||= Rails.cache.fetch(in_stock_cache_key, version: version) do
-        total_on_hand > 0
-      end
+      @in_stock ||= if association(:stock_items).loaded? && association(:stock_locations).loaded?
+                      total_on_hand.positive?
+                    else
+                      Rails.cache.fetch(in_stock_cache_key, version: cache_version) do
+                        total_on_hand.positive?
+                      end
+                    end
     end
 
     def backorderable?
@@ -321,6 +433,10 @@ module Spree
       end
     end
 
+    def on_sale?(currency)
+      @on_sale ||= price_in(currency)&.discounted?
+    end
+
     delegate :total_on_hand, :can_supply?, to: :quantifier
 
     alias is_backorderable? backorderable?
@@ -343,6 +459,12 @@ module Spree
       (width || 0) + (height || 0) + (depth || 0)
     end
 
+    # Returns the weight unit for the variant
+    # @return [String]
+    def weight_unit
+      attributes['weight_unit'] || Spree::Store.default.preferred_weight_unit
+    end
+
     def discontinue!
       update_attribute(:discontinue_on, Time.current)
     end
@@ -355,9 +477,17 @@ module Spree
       @backordered ||= !in_stock? && stock_items.exists?(backorderable: true)
     end
 
-    # Is this variant to be downloaded by the customer?
+    # Is this variant purely digital? (no physical product)
     def digital?
-      digitals.present?
+      product.digital?
+    end
+
+    def with_digital_assets?
+      digitals.any?
+    end
+
+    def clear_in_stock_cache
+      Rails.cache.delete(in_stock_cache_key)
     end
 
     private
@@ -386,14 +516,18 @@ module Spree
 
     # Ensures a new variant takes the product master price when price is not supplied
     def check_price
-      if price.nil? && Spree::Config[:require_master_price]
-        return errors.add(:base, :no_master_variant_found_to_infer_price)  unless product&.master
-        return errors.add(:base, :must_supply_price_for_variant_or_master) if self == product.master
+      return if (has_default_price? && default_price.valid?) || prices.any?
 
-        self.price = product.master.price
-      end
-      if price.present? && currency.nil?
-        self.currency = Spree::Store.default.default_currency
+      infer_price_from_default_variant_if_needed
+      self.currency = Spree::Store.default.default_currency if price.present? && currency.nil?
+    end
+
+    def infer_price_from_default_variant_if_needed
+      if price.nil?
+        return errors.add(:base, :no_master_variant_found_to_infer_price) unless product&.master
+
+        # At this point, master can have or have no price, so let's use price from the default variant
+        self.price = product.default_variant.price
       end
     end
 
@@ -411,12 +545,27 @@ module Spree
       "variant-#{id}-in_stock"
     end
 
-    def clear_in_stock_cache
-      Rails.cache.delete(in_stock_cache_key)
-    end
-
     def disable_sku_validation?
       Spree::Config[:disable_sku_validation]
     end
+
+    def clear_line_items_cache
+      line_items.update_all(updated_at: Time.current)
+    end
+
+    def handle_track_inventory_change
+      return unless track_inventory_previously_changed?
+      return if track_inventory
+
+      stock_items.update_all(backorderable: true, count_on_hand: 0, updated_at: Time.current)
+    end
+
+    def remove_prices_from_master_variant
+      product.master.prices.delete_all if prices.exists?
+    end
+
+    def remove_stock_items_from_master_variant
+      product.master.stock_items.delete_all
+    end
   end
 end

data/app/models/spree/wished_item.rb

@@ -1,5 +1,5 @@
 module Spree
-  class WishedItem < Spree::Base
+  class WishedItem < Spree.base_class
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
     end

data/app/models/spree/wishlist.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Wishlist < Spree::Base
+  class Wishlist < Spree.base_class
     include Spree::SingleStoreResource
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks

data/app/models/spree/zone.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Zone < Spree::Base
+  class Zone < Spree.base_class
     include Spree::UniqueName
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks

data/app/models/spree/zone_member.rb

@@ -1,5 +1,5 @@
 module Spree
-  class ZoneMember < Spree::Base
+  class ZoneMember < Spree.base_class
     belongs_to :zone, class_name: 'Spree::Zone', counter_cache: true, inverse_of: :zone_members
     belongs_to :zoneable, polymorphic: true
 

data/app/presenters/spree/csv/order_line_item_presenter.rb

@@ -0,0 +1,145 @@
+module Spree
+  module CSV
+    class OrderLineItemPresenter
+      HEADERS = [
+        'Number',
+        'Email',
+        'Status',
+        'Currency',
+        'Subtotal',
+        'Shipping',
+        'Taxes',
+        'Taxes included',
+        'Discount Used',
+        'Free Shipping',
+        'Discount',
+        'Discount Code',
+        'Store Credit amount',
+        'Total',
+        'Shipping method',
+        'Total weight',
+        'Payment Type Used',
+        'Product ID',
+        'Item Quantity',
+        'Item SKU',
+        'Item Name',
+        'Item Price',
+        'Item Total Discount',
+        'Item Total Price',
+        'Item requires shipping',
+        'Item taxbale',
+        'Item Vendor',
+        'Category lvl0',
+        'Category lvl1',
+        'Category lvl2',
+        'Category lvl3',
+        'Category lvl4',
+        'Billing Name',
+        'Billing Address 1',
+        'Billing Address 2',
+        'Billing Company',
+        'Billing City',
+        'Billing Zip',
+        'Billing State',
+        'Billing Country',
+        'Billing Phone',
+        'Shipping Name',
+        'Shipping Address 1',
+        'Shipping Address 2',
+        'Shipping Company',
+        'Shipping City',
+        'Shipping Zip',
+        'Shipping State',
+        'Shipping Country',
+        'Shipping Phone',
+        'Placed at',
+        'Shipped at',
+        'Cancelled at',
+        'Cancelled by',
+        'Notes'
+      ].freeze
+
+      def initialize(order, line_item, index)
+        @order = order
+        @line_item = line_item
+        @index = index
+      end
+
+      attr_accessor :order, :line_item, :index
+
+      def call
+        [
+          order.number,
+          index.zero? ? order.email : nil,
+          index.zero? ? order.state : nil,
+          index.zero? ? order.currency : nil,
+          index.zero? ? order.item_total.to_f : nil,
+          index.zero? ? order.shipment_total.to_f : nil,
+          index.zero? ? order.tax_total.to_f : nil,
+          index.zero? ? order.included_tax_total.positive? : nil,
+          index.zero? ? (order.promo_total.negative? || line_item.promo_total.negative?) : nil,
+          index.zero? ? order.has_free_shipping? : nil,
+          index.zero? ? order.promo_total.abs : nil,
+          index.zero? ? order.promo_code : nil,
+          index.zero? ? order.payments.store_credits.sum(:amount).abs : nil,
+          index.zero? ? order.total.to_f : nil,
+          index.zero? ? order.shipping_method&.name : nil,
+          index.zero? ? order.total_weight.to_f : nil,
+          index.zero? && order.payments.valid.any? ? order.payments.valid.first.display_source_name : nil,
+          line_item.product_id,
+          line_item.quantity,
+          line_item.sku,
+          line_item.name,
+          line_item.price,
+          line_item.promo_total.abs,
+          line_item.total,
+          !line_item.product.digital?,
+          line_item.product.tax_category.present?,
+          line_item.product.try(:vendor_name),
+          taxon_dict(line_item.product.main_taxon)[0],
+          taxon_dict(line_item.product.main_taxon)[1],
+          taxon_dict(line_item.product.main_taxon)[2],
+          taxon_dict(line_item.product.main_taxon)[3],
+          taxon_dict(line_item.product.main_taxon)[4],
+          index.zero? ? order.bill_address&.full_name : nil,
+          index.zero? ? order.bill_address&.address1 : nil,
+          index.zero? ? order.bill_address&.address2 : nil,
+          index.zero? ? order.bill_address&.company : nil,
+          index.zero? ? order.bill_address&.city : nil,
+          index.zero? ? order.bill_address&.zipcode : nil,
+          index.zero? ? order.bill_address&.state_name : nil,
+          index.zero? ? order.bill_address&.country&.name : nil,
+          index.zero? ? order.bill_address&.phone : nil,
+          index.zero? ? order.ship_address&.full_name : nil,
+          index.zero? ? order.ship_address&.address1 : nil,
+          index.zero? ? order.ship_address&.address2 : nil,
+          index.zero? ? order.ship_address&.company : nil,
+          index.zero? ? order.ship_address&.city : nil,
+          index.zero? ? order.ship_address&.zipcode : nil,
+          index.zero? ? order.ship_address&.state_name : nil,
+          index.zero? ? order.ship_address&.country&.name : nil,
+          index.zero? ? order.ship_address&.phone : nil,
+          index.zero? ? format_date(order.completed_at) : nil,
+          format_date(line_item.order.shipments.first&.shipped_at),
+          index.zero? ? format_date(order.canceled_at) : nil,
+          index.zero? ? order.canceler&.email : nil,
+          index.zero? ? order.special_instructions : nil
+        ]
+      end
+
+      private
+
+      def taxon_dict(taxon)
+        return [] if taxon.blank?
+
+        taxon.pretty_name.to_s.split('->').map(&:strip)
+      end
+
+      def format_date(date)
+        return nil if date.blank?
+
+        date.in_time_zone(order.store.preferred_timezone).strftime('%Y-%m-%d %H:%M:%S')
+      end
+    end
+  end
+end

data/app/presenters/spree/csv/product_presenter.rb

@@ -0,0 +1,63 @@
+require 'csv'
+
+module Spree
+  module CSV
+    class ProductPresenter
+      def initialize(product, properties = [], store = nil)
+        @product = product
+        @properties = properties
+        @store = store || product.stores.first
+        @currency = @store.default_currency
+      end
+
+      attr_accessor :product, :properties, :store, :currency
+
+      def call
+        [
+          product.id,
+          product.try(:vendor_name),
+          product.try(:brand_name),
+          product.name,
+          product.description&.html_safe,
+          product.amount_in(currency).to_f,
+          product.meta_title,
+          product.meta_description,
+          product.meta_keywords,
+          product.tag_list.to_s,
+          product.label_list.to_s,
+          product.width,
+          product.height,
+          product.depth,
+          product.weight,
+          product.available_on&.strftime('%Y-%m-%d %H:%M:%S'),
+          product.discontinue_on&.strftime('%Y-%m-%d %H:%M:%S'),
+          product.status,
+          *map_categories(product),
+          product.total_on_hand == BigDecimal::INFINITY ? '∞' : product.total_on_hand,
+          *present_properties
+        ]
+      end
+
+      private
+
+      def map_categories(product)
+        categories = [nil, nil, nil]
+
+        product.taxons.reorder(depth: :desc).first(3).pluck(:pretty_name).each_with_index do |category_name, index|
+          categories[index] = category_name
+        end
+
+        categories
+      end
+
+      def present_properties
+        properties.flat_map do |property|
+          [
+            property.name,
+            product.property(property.name)
+          ]
+        end
+      end
+    end
+  end
+end