spree_core 4.3.0 → 4.6.1

data/app/models/spree/taxon.rb

@@ -3,9 +3,17 @@ require 'stringex'
 
 module Spree
   class Taxon < Spree::Base
+    include TranslatableResource
+    include TranslatableResourceSlug
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     extend FriendlyId
     friendly_id :permalink, slug_column: :permalink, use: :history
     before_validation :set_permalink, on: :create, if: :name
+    alias_attribute :slug, :permalink
 
     acts_as_nested_set dependent: :destroy
 
@@ -22,7 +30,7 @@ module Spree
     has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', dependent: :destroy
     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 :name, presence: true, uniqueness: { scope: [:parent_id, :taxonomy_id], 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] }
@@ -37,6 +45,7 @@ module Spree
 
     before_validation :copy_taxonomy_from_parent
     after_save :touch_ancestors_and_taxonomy
+    after_update :sync_taxonomy_name
     after_touch :touch_ancestors_and_taxonomy
 
     has_one :icon, as: :viewable, dependent: :destroy, class_name: 'Spree::TaxonImage'
@@ -48,6 +57,26 @@ module Spree
 
     scope :for_stores, ->(stores) { joins(:taxonomy).where(spree_taxonomies: { store_id: stores.ids }) }
 
+    TRANSLATABLE_FIELDS = %i[name description permalink].freeze
+    translates(*TRANSLATABLE_FIELDS)
+
+    self::Translation.class_eval do
+      alias_attribute :slug, :permalink
+
+      before_create :set_permalink
+
+      def set_permalink
+        parent = translated_model.parent
+        name_with_fallback = name || translated_model.name
+
+        if parent.present?
+          self.permalink = [parent.permalink, (permalink.blank? ? name_with_fallback.to_url : permalink.split('/').last)].join('/')
+        else
+          self.permalink = name_with_fallback.to_url if permalink.blank?
+        end
+      end
+    end
+
     # indicate which filters should be used for a taxon
     # this method should be customized to your own site
     def applicable_filters
@@ -67,11 +96,7 @@ module Spree
 
     # Creates permalink base for friendly_id
     def set_permalink
-      if parent.present?
-        self.permalink = [parent.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')
-      else
-        self.permalink = name.to_url if permalink.blank?
-      end
+      translations.each(&:set_permalink)
     end
 
     def active_products
@@ -103,6 +128,14 @@ module Spree
 
     private
 
+    def sync_taxonomy_name
+      if saved_change_to_name? && root?
+        return if taxonomy.name.to_s == name.to_s
+
+        taxonomy.update(name: name)
+      end
+    end
+
     def touch_ancestors_and_taxonomy
       # Touches all ancestors at once to avoid recursive taxonomy touch, and reduce queries.
       ancestors.update_all(updated_at: Time.current)

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

@@ -5,9 +5,13 @@ module Spree
         extend ActiveSupport::Concern
 
         included do
-          validate :check_attachment_content_type
+          if Spree.public_storage_service_name
+            has_one_attached :attachment, service: Spree.public_storage_service_name
+          else
+            has_one_attached :attachment
+          end
 
-          has_one_attached :attachment
+          validates :attachment, content_type: /\Aimage\/.*\z/
 
           default_scope { includes(attachment_attachment: :blob) }
 
@@ -21,16 +25,6 @@ module Spree
           def default_style
             :mini
           end
-
-          def accepted_image_types
-            %w(image/jpeg image/jpg image/png image/gif)
-          end
-
-          def check_attachment_content_type
-            if attachment.attached? && !attachment.content_type.in?(accepted_image_types)
-              errors.add(:attachment, :not_allowed_content_type)
-            end
-          end
         end
       end
     end

data/app/models/spree/taxon_image.rb

@@ -6,10 +6,11 @@ module Spree
 
     def styles
       self.class.styles.map do |_, size|
-        width, height = size[/(\d+)x(\d+)/].split('x')
+        width, height = size[/(\d+)x(\d+)/].split('x').map(&:to_i)
 
         {
-          url: polymorphic_path(attachment.variant(resize: size), only_path: true),
+          url: generate_url(size: size),
+          size: size,
           width: width,
           height: height
         }

data/app/models/spree/taxonomy.rb

@@ -1,5 +1,14 @@
 module Spree
   class Taxonomy < Spree::Base
+    include TranslatableResource
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
+    TRANSLATABLE_FIELDS = %i[name].freeze
+    translates(*TRANSLATABLE_FIELDS)
+
     acts_as_list
 
     validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true, scope: :store_id }
@@ -10,10 +19,12 @@ module Spree
     belongs_to :store, class_name: 'Spree::Store'
 
     after_create :set_root
-    after_save :set_root_taxon_name
+    after_update :set_root_taxon_name
 
     default_scope { order("#{table_name}.position, #{table_name}.created_at") }
 
+    self.whitelisted_ransackable_associations = %w[root]
+
     private
 
     def set_root
@@ -21,6 +32,9 @@ module Spree
     end
 
     def set_root_taxon_name
+      return unless saved_change_to_name?
+      return if name.to_s == root.name.to_s
+
       root.update(name: name)
     end
   end

data/app/models/spree/variant.rb

@@ -4,20 +4,27 @@ module Spree
     acts_as_list scope: :product
 
     include MemoizedData
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
 
     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
 
-    delegate :name, :name=, :description, :slug, :available_on, :shipping_category_id,
+    delegate :name, :name=, :description, :slug, :available_on, :make_active_at, :shipping_category_id,
              :meta_description, :meta_keywords, :shipping_category, to: :product
 
+    auto_strip_attributes :sku, nullify: false
+
     # we need to have this callback before any dependent: :destroy associations
     # https://github.com/rails/rails/issues/3458
-    before_destroy :ensure_no_line_items
+    before_destroy :ensure_not_in_complete_orders
+    after_destroy :remove_line_items_from_incomplete_orders
 
-    # must include this after ensure_no_line_items to make sure price won't be deleted before validation
+    # must include this after ensure_not_in_complete_orders to make sure price won't be deleted before validation
     include Spree::DefaultPrice
 
     with_options inverse_of: :variant do
@@ -42,6 +49,10 @@ module Spree
              dependent: :destroy,
              inverse_of: :variant
 
+    has_many :wished_items, dependent: :destroy
+
+    has_many :digitals
+
     before_validation :set_cost_currency
 
     validate :check_price
@@ -52,7 +63,7 @@ module Spree
       validates :cost_price
       validates :price
     end
-    validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) }, case_sensitive: false },
+    validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) }, case_sensitive: false, scope: spree_base_uniqueness_scope },
                     allow_blank: true, unless: :disable_sku_validation?
 
     after_create :create_stock_items
@@ -89,7 +100,7 @@ module Spree
     scope :not_deleted, -> { where("#{Spree::Variant.quoted_table_name}.deleted_at IS NULL") }
 
     scope :for_currency_and_available_price_amount, ->(currency = nil) do
-      currency ||= Spree::Config[:currency]
+      currency ||= Spree::Store.default.default_currency
       joins(:prices).where('spree_prices.currency = ?', currency).where('spree_prices.amount IS NOT NULL').distinct
     end
 
@@ -106,32 +117,33 @@ module Spree
       end
     end
 
-    self.whitelisted_ransackable_associations = %w[option_values product prices default_price]
-    self.whitelisted_ransackable_attributes = %w[weight sku]
+    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)
 
     def self.product_name_or_sku_cont(query)
-      joins(:product).where("LOWER(#{Product.table_name}.name) LIKE LOWER(:query) OR LOWER(sku) LIKE LOWER(:query)", query: "%#{query}%")
+      joins(:product).join_translation_table(Product).
+        where("LOWER(#{Product.translation_table_alias}.name) LIKE LOWER(:query)
+               OR LOWER(sku) LIKE LOWER(:query)", query: "%#{query}%")
     end
 
     def self.search_by_product_name_or_sku(query)
-      if defined?(SpreeGlobalize)
-        joins(product: :translations).where("LOWER(#{Product::Translation.table_name}.name) LIKE LOWER(:query) OR LOWER(sku) LIKE LOWER(:query)",
-                                            query: "%#{query}%")
-      else
-        product_name_or_sku_cont(query)
-      end
+      product_name_or_sku_cont(query)
     end
 
     def available?
       !discontinued? && product.available?
     end
 
+    def in_stock_or_backorderable?
+      self.class.in_stock_or_backorderable.exists?(id: id)
+    end
+
     def tax_category
       @tax_category ||= if self[:tax_category_id].nil?
                           product.tax_category
                         else
-                          Spree::TaxCategory.find(self[:tax_category_id])
+                          Spree::TaxCategory.find_by(id: self[:tax_category_id]) || product.tax_category
                         end
     end
 
@@ -157,6 +169,8 @@ module Spree
 
     def options=(options = {})
       options.each do |option|
+        next if option[:name].blank? || option[:value].blank?
+
         set_option_value(option[:name], option[:value])
       end
     end
@@ -165,12 +179,12 @@ module Spree
       # no option values on master
       return if is_master
 
-      option_type = Spree::OptionType.where(name: opt_name).first_or_initialize do |o|
-        o.presentation = opt_name
+      option_type = Spree::OptionType.where(['LOWER(name) = ?', opt_name.downcase.strip]).first_or_initialize do |o|
+        o.name = o.presentation = opt_name
         o.save!
       end
 
-      current_value = option_values.detect { |o| o.option_type.name == opt_name }
+      current_value = find_option_value(opt_name)
 
       if current_value.nil?
         # then we have to check to make sure that the product has the option type
@@ -178,13 +192,13 @@ module Spree
           product.option_types << option_type
         end
       else
-        return if current_value.name == opt_value
+        return if current_value.name.downcase.strip == opt_value.downcase.strip
 
         option_values.delete(current_value)
       end
 
-      option_value = Spree::OptionValue.where(option_type_id: option_type.id, name: opt_value).first_or_initialize do |o|
-        o.presentation = opt_value
+      option_value = option_type.option_values.where(['LOWER(name) = ?', opt_value.downcase.strip]).first_or_initialize do |o|
+        o.name = o.presentation = opt_value
         o.save!
       end
 
@@ -192,12 +206,29 @@ module Spree
       save
     end
 
+    def find_option_value(opt_name)
+      option_values.detect { |o| o.option_type.name.downcase.strip == opt_name.downcase.strip }
+    end
+
     def option_value(opt_name)
-      option_values.detect { |o| o.option_type.name == opt_name }.try(:presentation)
+      find_option_value(opt_name).try(:presentation)
     end
 
     def price_in(currency)
-      prices.detect { |price| price.currency == currency&.upcase } || prices.build(currency: currency&.upcase)
+      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
+      end
+    rescue TypeError
+      find_or_build_price.call
     end
 
     def amount_in(currency)
@@ -276,10 +307,6 @@ module Spree
       track_inventory? && Spree::Config.track_inventory_levels
     end
 
-    def track_inventory
-      should_track_inventory?
-    end
-
     def volume
       (width || 0) * (height || 0) * (depth || 0)
     end
@@ -300,15 +327,24 @@ module Spree
       @backordered ||= !in_stock? && stock_items.exists?(backorderable: true)
     end
 
+    # Is this variant to be downloaded by the customer?
+    def digital?
+      digitals.present?
+    end
+
     private
 
-    def ensure_no_line_items
-      if line_items.any?
+    def ensure_not_in_complete_orders
+      if orders.complete.any?
         errors.add(:base, :cannot_destroy_if_attached_to_line_items)
         throw(:abort)
       end
     end
 
+    def remove_line_items_from_incomplete_orders
+      Spree::Variants::RemoveFromIncompleteOrdersJob.perform_later(self)
+    end
+
     def quantifier
       Spree::Stock::Quantifier.new(self)
     end
@@ -329,12 +365,12 @@ module Spree
         self.price = product.master.price
       end
       if price.present? && currency.nil?
-        self.currency = Spree::Config[:currency]
+        self.currency = Spree::Store.default.default_currency
       end
     end
 
     def set_cost_currency
-      self.cost_currency = Spree::Config[:currency] if cost_currency.blank?
+      self.cost_currency = Spree::Store.default.default_currency if cost_currency.blank?
     end
 
     def create_stock_items

data/app/models/spree/wished_item.rb

@@ -0,0 +1,33 @@
+module Spree
+  class WishedItem < Spree::Base
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
+    extend DisplayMoney
+    money_methods :total, :price
+
+    belongs_to :variant, class_name: 'Spree::Variant'
+    belongs_to :wishlist, class_name: 'Spree::Wishlist'
+
+    has_one :product, class_name: 'Spree::Product', through: :variant
+
+    validates :variant, :wishlist, presence: true
+    validates :variant, uniqueness: { scope: [:wishlist] }
+    validates :quantity, numericality: { only_integer: true, greater_than: 0 }
+
+    def price(currency)
+      variant.amount_in(currency[:currency])
+    end
+
+    def total(currency)
+      variant_price = variant.amount_in(currency[:currency])
+
+      if variant_price.nil?
+        variant_price
+      else
+        quantity * variant_price
+      end
+    end
+  end
+end

data/app/models/spree/wishlist.rb

@@ -0,0 +1,38 @@
+module Spree
+  class Wishlist < Spree::Base
+    include SingleStoreResource
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
+    has_secure_token
+
+    belongs_to :user, class_name: "::#{Spree.user_class}", touch: true
+    belongs_to :store, class_name: 'Spree::Store'
+
+    has_many :wished_items, class_name: 'Spree::WishedItem', dependent: :destroy
+
+    after_commit :ensure_default_exists_and_is_unique
+    validates :name, :store, :user, presence: true
+
+    def include?(variant_id)
+      wished_items.exists?(variant_id: variant_id)
+    end
+
+    def to_param
+      token
+    end
+
+    def self.get_by_param(param)
+      find_by(token: param)
+    end
+
+    private
+
+    def ensure_default_exists_and_is_unique
+      if is_default?
+        Wishlist.where(is_default: true, user_id: user_id, store_id: store_id).where.not(id: id).update_all(is_default: false)
+      end
+    end
+  end
+end

data/app/models/spree/zone.rb

@@ -1,5 +1,10 @@
 module Spree
   class Zone < Spree::Base
+    include UniqueName
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     with_options dependent: :destroy, inverse_of: :zone do
       has_many :zone_members, class_name: 'Spree::ZoneMember'
       has_many :tax_rates
@@ -12,8 +17,6 @@ module Spree
     has_many :shipping_method_zones, class_name: 'Spree::ShippingMethodZone'
     has_many :shipping_methods, through: :shipping_method_zones, class_name: 'Spree::ShippingMethod'
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
-
     scope :with_default_tax, -> { where(default_tax: true) }
 
     after_save :remove_defunct_members
@@ -71,7 +74,9 @@ module Spree
     end
 
     def self.default_checkout_zone
-      find_by(name: Spree::Config[:checkout_zone])
+      ActiveSupport::Deprecation.warn('Spree::Zone.default_checkout_zone is deprecated and will be removed in Spree 5')
+
+      first
     end
 
     def kind
@@ -109,10 +114,10 @@ module Spree
     def country_list
       @countries ||= case kind
                      when 'country' then
-                       zoneables
+                       Country.where(id: country_ids)
                      when 'state' then
-                       zoneables.collect(&:country)
-                     end.flatten.compact.uniq
+                       Country.where(id: zoneables.collect(&:country_id))
+                     end
     end
 
     def <=>(other)

data/app/services/spree/account/addresses/create.rb

@@ -1,23 +1,7 @@
 module Spree
   module Account
     module Addresses
-      class Create
-        prepend Spree::ServiceModule::Base
-        include Spree::Account::Addresses::Helper
-
-        attr_accessor :country
-
-        def call(user:, address_params:)
-          fill_country_and_state_ids(address_params)
-
-          address = user.addresses.new(address_params)
-          if address.save
-            assign_to_user_as_default(user: user, address_id: address.id)
-            success(address)
-          else
-            failure(address)
-          end
-        end
+      class Create < Spree::Addresses::Create
       end
     end
   end

data/app/services/spree/account/addresses/update.rb

@@ -1,28 +1,7 @@
 module Spree
   module Account
     module Addresses
-      class Update
-        prepend Spree::ServiceModule::Base
-        include Spree::Account::Addresses::Helper
-
-        attr_accessor :country
-
-        def call(address:, address_params:)
-          address_params[:country_id] ||= address.country_id
-          fill_country_and_state_ids(address_params)
-
-          if address&.editable?
-            address.update(address_params) ? success(address) : failure(address)
-          else
-            new_address(address_params).valid? ? address.destroy && success(new_address) : failure(new_address)
-          end
-        end
-
-        private
-
-        def new_address(address_params = {})
-          @new_address ||= ::Spree::Address.find_or_create_by(address_params.except(:id, :updated_at, :created_at))
-        end
+      class Update < Spree::Addresses::Update
       end
     end
   end

data/app/services/spree/addresses/create.rb

@@ -0,0 +1,24 @@
+module Spree
+  module Addresses
+    class Create
+      prepend Spree::ServiceModule::Base
+      include Spree::Addresses::Helper
+
+      attr_accessor :country
+
+      def call(address_params: {}, user: nil)
+        address_params = fill_country_and_state_ids(address_params)
+
+        address = Spree::Address.new(address_params)
+        address.user = user if user.present?
+
+        if address.save
+          assign_to_user_as_default(user: user, address_id: address.id) if user.present?
+          success(address)
+        else
+          failure(address)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/addresses/helper.rb

@@ -0,0 +1,41 @@
+module Spree
+  module Addresses
+    module Helper
+      private
+
+      attr_accessor :country
+
+      def fill_country_and_state_ids(params)
+        replace_country_iso_with_id(params)
+        fill_state_id(params)
+      end
+
+      def replace_country_iso_with_id(params)
+        iso = params[:country_iso]
+        return params unless iso.present?
+
+        country = Spree::Country.by_iso(iso)
+        params[:country_id] = country&.id
+        params.delete(:country_iso)
+        params
+      end
+
+      def fill_state_id(params)
+        state_name = params[:state_name]
+        return params unless state_name.present?
+
+        country ||= Spree::Country.find(params[:country_id]) if params[:country_id].present?
+        return params unless country
+
+        params[:state_id] = country.states.find_by(name: state_name)&.id
+        params
+      end
+
+      def assign_to_user_as_default(user:, address_id:)
+        if user.addresses.pluck(:id) == [address_id] # check if it's user first address
+          user.update(bill_address_id: address_id, ship_address_id: address_id)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/addresses/update.rb

@@ -0,0 +1,32 @@
+module Spree
+  module Addresses
+    class Update
+      prepend Spree::ServiceModule::Base
+      include Spree::Addresses::Helper
+
+      attr_accessor :country
+
+      def call(address:, address_params:)
+        address_params[:country_id] ||= address.country_id
+        address_params = fill_country_and_state_ids(address_params)
+
+        if address&.editable?
+          address.update(address_params) ? success(address) : failure(address)
+        else
+          if new_address(address_params).valid?
+            address.destroy
+            success(new_address)
+          else
+            failure(new_address)
+          end
+        end
+      end
+
+      private
+
+      def new_address(address_params = {})
+        @new_address ||= ::Spree::Address.find_or_create_by(address_params.except(:id, :updated_at, :created_at))
+      end
+    end
+  end
+end