spree_core 4.3.0 → 4.5.1

data/app/models/spree/taxonomy.rb

@@ -1,5 +1,10 @@
 module Spree
   class Taxonomy < Spree::Base
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     acts_as_list
 
     validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true, scope: :store_id }
@@ -10,10 +15,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 +28,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,8 +117,8 @@ 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)
@@ -127,11 +138,15 @@ module Spree
       !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 +172,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 +182,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 +195,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 +209,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 +310,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 +330,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 +368,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

data/app/services/spree/cart/add_item.rb

@@ -3,7 +3,7 @@ module Spree
     class AddItem
       prepend Spree::ServiceModule::Base
 
-      def call(order:, variant:, quantity: nil, options: {})
+      def call(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
         ApplicationRecord.transaction do
           run :add_to_line_item
           run Spree::Dependencies.cart_recalculate_service.constantize
@@ -12,7 +12,7 @@ module Spree
 
       private
 
-      def add_to_line_item(order:, variant:, quantity: nil, options: {})
+      def add_to_line_item(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
         options ||= {}
         quantity ||= 1
 
@@ -32,6 +32,8 @@ module Spree
         end
 
         line_item.target_shipment = options[:shipment] if options.key? :shipment
+        line_item.public_metadata = public_metadata.to_h if public_metadata
+        line_item.private_metadata = private_metadata.to_h if private_metadata
 
         return failure(line_item) unless line_item.save
 

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

@@ -3,7 +3,7 @@ module Spree
     class Create
       prepend Spree::ServiceModule::Base
 
-      def call(user:, store:, currency:, order_params: nil)
+      def call(user:, store:, currency:, public_metadata: {}, private_metadata: {}, order_params: {})
         order_params ||= {}
 
         # we cannot create an order without store
@@ -12,7 +12,9 @@ module Spree
         default_params = {
           user: user,
           currency: currency || store.default_currency,
-          token: Spree::GenerateToken.new.call(Spree::Order)
+          token: Spree::GenerateToken.new.call(Spree::Order),
+          public_metadata: public_metadata.to_h,
+          private_metadata: private_metadata.to_h
         }
 
         order = store.orders.create!(default_params.merge(order_params))

data/app/services/spree/cart/remove_line_item.rb

@@ -11,6 +11,7 @@ module Spree
                                                                             line_item: line_item,
                                                                             options: options)
         end
+        order.reload
         success(line_item)
       end
     end

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

@@ -25,10 +25,10 @@ module Spree
       def filter_order_items(order, params)
         return params if params[:line_items_attributes].nil? || params[:line_items_attributes][:id]
 
-        line_item_ids = order.line_items.pluck(:id)
+        line_item_ids = order.line_item_ids.map(&:to_s)
 
         params[:line_items_attributes].each_pair do |id, value|
-          params[:line_items_attributes].delete(id) unless line_item_ids.include?(value[:id].to_i) || value[:variant_id].present?
+          params[:line_items_attributes].delete(id) unless line_item_ids.include?(value[:id].to_s) || value[:variant_id].present?
         end
         params
       end

data/app/services/spree/checkout/add_store_credit.rb

@@ -9,9 +9,12 @@ module Spree
 
         remaining_total = amount ? [amount, @order.outstanding_balance].min : @order.outstanding_balance
 
+        return failure(nil, Spree.t(:error_user_does_not_have_any_store_credits)) unless @order.user&.store_credits&.any?
+
         ApplicationRecord.transaction do
           @order.payments.store_credits.where(state: :checkout).map(&:invalidate!)
-          apply_store_credits(remaining_total) if @order.user&.store_credits&.any?
+
+          apply_store_credits(remaining_total)
         end
 
         @order.reload.payments.store_credits.valid.any? ? success(@order) : failure(@order)

data/app/services/spree/checkout/select_shipping_method.rb

@@ -0,0 +1,49 @@
+module Spree
+  module Checkout
+    class SelectShippingMethod
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, params:)
+        if params[:shipment_id].present?
+          shipment = order.shipments.valid.find_by(id: params[:shipment_id])
+          return failure(:shipment_not_found) if shipment.nil?
+        end
+
+        shipping_method = Spree::ShippingMethod.find_by(id: params[:shipping_method_id])
+        return failure(:shipping_method_not_found) if shipping_method.nil?
+
+        # single shipment passed
+        if shipment.present?
+          result = set_shipping_rate_based_on_method(shipment: shipment, shipping_method: shipping_method)
+
+          return failure(result.value, result.error) unless result.success?
+        else
+          # set shipping method for all shipments
+          order.shipments.valid.each do |s|
+            result = set_shipping_rate_based_on_method(shipment: s, shipping_method: shipping_method)
+
+            return failure(result.value, result.error) unless result.success?
+          end
+        end
+
+        success(order)
+      end
+
+      def set_shipping_rate_based_on_method(shipment:, shipping_method:)
+        selected_shipping_rate = shipment.shipping_rates.find_by(shipping_method: shipping_method)
+
+        if selected_shipping_rate.nil?
+          return failure(
+            :selected_shipping_method_not_found,
+            "Couldn't find shipping rates for Shipping Method with ID = #{shipping_method.id} and Shipment with ID = #{shipment.id}"
+          )
+        end
+
+        shipment.selected_shipping_rate_id = selected_shipping_rate.id
+        shipment.update_amounts
+
+        success(shipment)
+      end
+    end
+  end
+end