spree_core 4.1.13 → 4.2.0.rc4

data/app/models/spree/shipping_rate.rb

@@ -1,9 +1,8 @@
 module Spree
   class ShippingRate < Spree::Base
     belongs_to :shipment, class_name: 'Spree::Shipment'
-    belongs_to :tax_rate, class_name: 'Spree::TaxRate'
-    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
-
+    belongs_to :tax_rate, -> { with_deleted }, class_name: 'Spree::TaxRate'
+    belongs_to :shipping_method, -> { with_deleted }, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
     extend Spree::DisplayMoney
 
     money_methods :base_price, :final_price, :tax_amount
@@ -32,14 +31,6 @@ module Spree
       @tax_amount ||= tax_rate&.calculator&.compute_shipping_rate(self) || BigDecimal(0)
     end
 
-    def shipping_method
-      Spree::ShippingMethod.unscoped { super }
-    end
-
-    def tax_rate
-      Spree::TaxRate.unscoped { super }
-    end
-
     # returns base price - any available discounts for this Shipment
     # useful when you want to present a list of available shipping rates
     def final_price

data/app/models/spree/stock/availability_validator.rb

@@ -14,10 +14,9 @@ module Spree
         display_name = variant.name.to_s
         display_name += " (#{variant.options_text})" unless variant.options_text.blank?
 
-        line_item.errors[:quantity] << Spree.t(
-          :selected_quantity_not_available,
-          item: display_name.inspect
-        )
+        line_item.errors.add(:quantity,
+                             :selected_quantity_not_available,
+                             message: Spree.t(:selected_quantity_not_available, item: display_name.inspect))
       end
 
       private

data/app/models/spree/stock_item.rb

@@ -4,7 +4,7 @@ module Spree
 
     with_options inverse_of: :stock_items do
       belongs_to :stock_location, class_name: 'Spree::StockLocation'
-      belongs_to :variant, class_name: 'Spree::Variant'
+      belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant'
     end
     has_many :stock_movements, inverse_of: :stock_item
 
@@ -56,10 +56,6 @@ module Spree
       in_stock? || backorderable?
     end
 
-    def variant
-      Spree::Variant.unscoped { super }
-    end
-
     def reduce_count_on_hand_to_zero
       set_count_on_hand(0) if count_on_hand > 0
     end

data/app/models/spree/stock_location.rb

@@ -106,8 +106,19 @@ module Spree
     private
 
     def create_stock_items
-      Variant.includes(:product).find_each do |variant|
-        propagate_variant(variant)
+      variants_scope = Spree::Variant
+      prepared_stock_items = variants_scope.ids.map do |variant_id|
+        Hash[
+          'stock_location_id', id,
+          'variant_id', variant_id,
+          'backorderable', backorderable_default,
+          'created_at', Time.current,
+          'updated_at', Time.current
+        ]
+      end
+      if prepared_stock_items.any?
+        stock_items.insert_all(prepared_stock_items)
+        variants_scope.touch_all
       end
     end
 

data/app/models/spree/store.rb

@@ -2,12 +2,27 @@ module Spree
   class Store < Spree::Base
     has_many :orders, class_name: 'Spree::Order'
     has_many :payment_methods, class_name: 'Spree::PaymentMethod'
+    belongs_to :default_country, class_name: 'Spree::Country'
+    belongs_to :checkout_zone, class_name: 'Spree::Zone'
 
     with_options presence: true do
-      validates :name, :url, :mail_from_address
-      validates :default_currency
+      validates :name, :url, :mail_from_address, :default_currency, :code
     end
 
+    validates :code, uniqueness: true
+
+    if !ENV['SPREE_DISABLE_DB_CONNECTION'] &&
+        connected? &&
+        table_exists? &&
+        connection.column_exists?(:spree_stores, :new_order_notifications_email)
+      validates :new_order_notifications_email, email: { allow_blank: true }
+    end
+
+    has_one_attached :logo
+    has_one_attached :mailer_logo
+
+    validates :mailer_logo, content_type: ['image/png', 'image/jpg', 'image/jpeg']
+
     before_save :ensure_default_exists_and_is_unique
     before_destroy :validate_not_default
 
@@ -15,6 +30,8 @@ module Spree
 
     after_commit :clear_cache
 
+    alias_attribute :contact_email, :customer_support_email
+
     def self.current(domain = nil)
       current_store = domain ? Store.by_url(domain).first : nil
       current_store || Store.default
@@ -26,6 +43,38 @@ module Spree
       end
     end
 
+    def supported_currencies_list
+      (read_attribute(:supported_currencies).to_s.split(',') << default_currency).map(&:to_s).map do |code|
+        ::Money::Currency.find(code.strip)
+      end.uniq.compact
+    end
+
+    def unique_name
+      "#{name} (#{code})"
+    end
+
+    def formatted_url
+      return if url.blank?
+
+      if url.match(/http:\/\/|https:\/\//)
+        url
+      else
+        Rails.env.development? ? "http://#{url}" : "https://#{url}"
+      end
+    end
+
+    def countries_available_for_checkout
+      checkout_zone_or_default.try(:country_list) || Spree::Country.all
+    end
+
+    def states_available_for_checkout(country)
+      checkout_zone_or_default.try(:state_list_for, country) || country.states
+    end
+
+    def checkout_zone_or_default
+      checkout_zone || Spree::Zone.default_checkout_zone
+    end
+
     private
 
     def ensure_default_exists_and_is_unique

data/app/models/spree/store_credit.rb

@@ -68,7 +68,7 @@ module Spree
     end
 
     def validate_authorization(amount, order_currency)
-      if amount_remaining.to_d < amount.to_d
+      if BigDecimal(amount_remaining, 3) < BigDecimal(amount, 3)
         errors.add(:base, Spree.t('store_credit_payment_method.insufficient_funds'))
       elsif currency != order_currency
         errors.add(:base, Spree.t('store_credit_payment_method.currency_mismatch'))

data/app/models/spree/variant.rb

@@ -3,7 +3,7 @@ module Spree
     acts_as_paranoid
     acts_as_list scope: :product
 
-    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :variants
+    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,
@@ -103,10 +103,19 @@ module Spree
 
     self.whitelisted_ransackable_associations = %w[option_values product prices default_price]
     self.whitelisted_ransackable_attributes = %w[weight sku]
-    self.whitelisted_ransackable_scopes = %i(product_name_or_sku_cont)
+    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("#{Product.table_name}.name LIKE :query OR sku LIKE :query", query: "%#{query}%")
+      joins(:product).where("LOWER(#{Product.table_name}.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
     end
 
     def available?
@@ -141,13 +150,6 @@ module Spree
       !!deleted_at
     end
 
-    # Product may be created with deleted_at already set,
-    # which would make AR's default finder return nil.
-    # This is a stopgap for that little problem.
-    def product
-      Spree::Product.unscoped { super }
-    end
-
     def options=(options = {})
       options.each do |option|
         set_option_value(option[:name], option[:value])
@@ -223,6 +225,10 @@ module Spree
       end.sum
     end
 
+    def compare_at_price
+      price_in(cost_currency).try(:compare_at_amount)
+    end
+
     def name_and_sku
       "#{name} - #{sku}"
     end

data/app/models/spree/zone.rb

@@ -70,6 +70,10 @@ module Spree
       matches.first
     end
 
+    def self.default_checkout_zone
+      find_by(name: Spree::Config[:checkout_zone])
+    end
+
     def kind
       if self[:kind].present?
         self[:kind]
@@ -97,8 +101,6 @@ module Spree
           zone_member.zoneable_id == address.country_id
         when 'Spree::State'
           zone_member.zoneable_id == address.state_id
-        else
-          false
         end
       end
     end
@@ -110,8 +112,6 @@ module Spree
                        zoneables
                      when 'state' then
                        zoneables.collect(&:country)
-                     else
-                       []
                      end.flatten.compact.uniq
     end
 
@@ -167,6 +167,19 @@ module Spree
       true
     end
 
+    def state_list
+      case kind
+      when 'country'
+        zoneables.map(&:states)
+      when 'state'
+        zoneables
+      end.flatten.compact.uniq
+    end
+
+    def state_list_for(country)
+      state_list.select { |state| state.country == country }
+    end
+
     private
 
     def remove_defunct_members

data/app/presenters/spree/variant_presenter.rb

@@ -3,19 +3,23 @@ module Spree
     include Rails.application.routes.url_helpers
     include Spree::BaseHelper
 
-    attr_reader :current_currency, :current_price_options
+    attr_reader :current_currency, :current_price_options, :current_store
 
     def initialize(opts = {})
       @variants = opts[:variants]
       @is_product_available_in_currency = opts[:is_product_available_in_currency]
       @current_currency = opts[:current_currency]
       @current_price_options = opts[:current_price_options]
+      @current_store = opts[:current_store]
     end
 
     def call
       @variants.map do |variant|
         {
           display_price: display_price(variant),
+          price: variant.price_in(current_currency),
+          display_compare_at_price: display_compare_at_price(variant),
+          should_display_compare_at_price: should_display_compare_at_price(variant),
           is_product_available_in_currency: @is_product_available_in_currency,
           backorderable: backorderable?(variant),
           in_stock: in_stock?(variant),
@@ -71,5 +75,9 @@ module Spree
         purchasable: variant.purchasable?
       }
     end
+
+    def should_display_compare_at_price(variant)
+      variant.compare_at_price.present? && variant.compare_at_price > variant.price
+    end
   end
 end

data/app/presenters/spree/variants/option_types_presenter.rb

@@ -76,6 +76,7 @@ module Spree
             id: option_value.id,
             position: option_value.position,
             presentation: option_value.presentation,
+            name: option_value.name,
             variant_id: option_value.variants.where(id: @variant_ids).order(:position).first.id,
             is_default: option_value == default_variant_data[:option_value]
           }

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

@@ -1,7 +1,12 @@
 module Spree
   module Account
     module Addresses
-      class Create < ::Spree::Account::Addresses::Base
+      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)
 

data/app/services/spree/account/addresses/{base.rb → helper.rb}

@@ -1,9 +1,7 @@
 module Spree
   module Account
     module Addresses
-      class Base
-        prepend Spree::ServiceModule::Base
-
+      module Helper
         private
 
         attr_accessor :country

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

@@ -1,7 +1,12 @@
 module Spree
   module Account
     module Addresses
-      class Update < ::Spree::Account::Addresses::Base
+      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)

data/app/services/spree/compare_line_items.rb

@@ -1,9 +1,11 @@
 # This class should be refactored
 module Spree
   class CompareLineItems
-    prepend Spree::ServiceModule:: Base
+    prepend Spree::ServiceModule::Base
+
+    def call(order:, line_item:, options: {}, comparison_hooks: nil)
+      comparison_hooks ||= Rails.application.config.spree.line_item_comparison_hooks
 
-    def call(order:, line_item:, options: {}, comparison_hooks: Rails.application.config.spree.line_item_comparison_hooks)
       legacy_part = comparison_hooks.all? do |hook|
         order.send(hook, line_item, options)
       end

data/app/sorters/spree/base_sorter.rb

@@ -0,0 +1,35 @@
+module Spree
+  class BaseSorter
+    def initialize(scope, params = {}, allowed_sort_attributes = [])
+      @scope = scope
+      @sort = params[:sort]
+      @allowed_sort_attributes = allowed_sort_attributes
+    end
+
+    def call
+      by_param_attribute(scope)
+    end
+
+    protected
+
+    attr_reader :scope, :collection, :sort, :allowed_sort_attributes
+
+    def by_param_attribute(scope)
+      return scope if sort_field.blank? || !allowed_sort_attributes.include?(sort_field.to_sym)
+
+      scope.order("#{sort_field}": order_direction)
+    end
+
+    def desc_order
+      @desc_order ||= String(sort)[0] == '-'
+    end
+
+    def sort_field
+      @sort_field ||= desc_order ? sort[1..-1] : sort
+    end
+
+    def order_direction
+      desc_order ? :desc : :asc
+    end
+  end
+end

data/app/sorters/spree/orders/sort.rb

@@ -1,42 +1,6 @@
 module Spree
   module Orders
-    class Sort
-      attr_reader :scope, :sort
-
-      def initialize(scope, params)
-        @scope = scope
-        @sort = params[:sort]
-      end
-
-      def call
-        orders = completed_at(scope)
-
-        orders
-      end
-
-      private
-
-      def desc_order
-        @desc_order ||= String(sort)[0] == '-'
-      end
-
-      def sort_field
-        @sort_field ||= desc_order ? sort[1..-1] : sort
-      end
-
-      def order_direction
-        desc_order ? :asc : :desc
-      end
-
-      def completed_at?
-        sort_field.eql?('completed_at')
-      end
-
-      def completed_at(orders)
-        return orders unless completed_at?
-
-        orders.order(completed_at: order_direction)
-      end
+    class Sort < ::Spree::BaseSorter
     end
   end
 end