spree_core 4.1.5 → 4.2.0.beta

data/app/models/spree/line_item.rb

@@ -57,7 +57,16 @@ module Spree
     end
 
     def update_price
-      self.price = variant.price_including_vat_for(tax_zone: tax_zone)
+      if Spree::Config.allow_currency_change == true
+        currency_price = Spree::Price.where(
+          currency: order.currency,
+          variant_id: variant_id
+        ).first
+
+        self.price = currency_price.price_including_vat_for(tax_zone: tax_zone)
+      else
+        self.price = variant.price_including_vat_for(tax_zone: tax_zone)
+      end
     end
 
     def copy_tax_category

data/app/models/spree/option_type.rb

@@ -24,7 +24,11 @@ module Spree
     after_touch :touch_all_products
 
     def filter_param
-      presentation.titleize.delete(' ').downcase
+      name.titleize.delete(' ').downcase
+    end
+
+    def self.color
+      find_by(name: 'color')
     end
 
     private

data/app/models/spree/order.rb

@@ -297,15 +297,15 @@ module Spree
     def outstanding_balance
       if canceled?
         -1 * payment_total
-      elsif refunds.exists?
-        # If refund has happened add it back to total to prevent balance_due payment state
-        # See: https://github.com/spree/spree/issues/6229 & https://github.com/spree/spree/issues/8136
-        total - (payment_total + refunds.sum(:amount))
       else
-        total - payment_total
+        total - (payment_total + reimbursement_paid_total)
       end
     end
 
+    def reimbursement_paid_total
+      reimbursements.sum(&:paid_amount)
+    end
+
     def outstanding_balance?
       outstanding_balance != 0
     end
@@ -351,6 +351,8 @@ module Spree
 
       deliver_order_confirmation_email unless confirmation_delivered?
 
+      deliver_store_owner_order_notification_email if deliver_store_owner_order_notification_email?
+
       consider_risk
     end
 
@@ -641,6 +643,13 @@ module Spree
         sum(:amount)
     end
 
+    def has_free_shipping?
+      promotions.
+        joins(:promotion_actions).
+        where(spree_promotion_actions: { type: 'Spree::Promotion::Actions::FreeShipping' }).
+        exists?
+    end
+
     private
 
     def link_by_email
@@ -706,5 +715,17 @@ module Spree
     def credit_card_nil_payment?(attributes)
       payments.store_credits.present? && attributes[:amount].to_f.zero?
     end
+
+    # Returns true if:
+    #   1. an email address is set for new order notifications AND
+    #   2. no notification for this order has been sent yet.
+    def deliver_store_owner_order_notification_email?
+      store.new_order_notifications_email.present? && !store_owner_notification_delivered?
+    end
+
+    def deliver_store_owner_order_notification_email
+      OrderMailer.store_owner_notification_email(id).deliver_later
+      update_column(:store_owner_notification_delivered, true)
+    end
   end
 end

data/app/models/spree/price.rb

@@ -15,10 +15,16 @@ module Spree
       less_than_or_equal_to: MAXIMUM_AMOUNT
     }
 
+    validates :compare_at_amount, allow_nil: true, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: MAXIMUM_AMOUNT
+    }
+
     extend DisplayMoney
-    money_methods :amount, :price
+    money_methods :amount, :price, :compare_at_amount
+    alias display_compare_at_price display_compare_at_amount
 
-    self.whitelisted_ransackable_attributes = ['amount']
+    self.whitelisted_ransackable_attributes = ['amount', 'compare_at_amount']
 
     def money
       Spree::Money.new(amount || 0, currency: currency)
@@ -28,17 +34,35 @@ module Spree
       self[:amount] = Spree::LocalizedNumber.parse(amount)
     end
 
+    def compare_at_money
+      Spree::Money.new(compare_at_amount || 0, currency: currency)
+    end
+
+    def compare_at_amount=(compare_at_amount)
+      self[:compare_at_amount] = Spree::LocalizedNumber.parse(compare_at_amount)
+    end
+
     alias_attribute :price, :amount
+    alias_attribute :compare_at_price, :compare_at_amount
 
     def price_including_vat_for(price_options)
       options = price_options.merge(tax_category: variant.tax_category)
       gross_amount(price, options)
     end
 
+    def compare_at_price_including_vat_for(price_options)
+      options = price_options.merge(tax_category: variant.tax_category)
+      gross_amount(compare_at_price, options)
+    end
+
     def display_price_including_vat_for(price_options)
       Spree::Money.new(price_including_vat_for(price_options), currency: currency)
     end
 
+    def display_compare_at_price_including_vat_for(price_options)
+      Spree::Money.new(compare_at_price_including_vat_for(price_options), currency: currency)
+    end
+
     # Remove variant default_scope `deleted_at: nil`
     def variant
       Spree::Variant.unscoped { super }

data/app/models/spree/product.rb

@@ -111,19 +111,19 @@ module Spree
 
     alias options product_option_types
 
-    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
+    self.whitelisted_ransackable_associations = %w[taxons stores variants_including_master master variants]
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on]
-    self.whitelisted_ransackable_scopes = %w[not_discontinued]
+    self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name]
 
     [
       :sku, :price, :currency, :weight, :height, :width, :depth, :is_master,
-      :cost_currency, :price_in, :amount_in, :cost_price
+      :cost_currency, :price_in, :amount_in, :cost_price, :compare_at_price
     ].each do |method_name|
       delegate method_name, :"#{method_name}=", to: :find_or_build_master
     end
 
     delegate :display_amount, :display_price, :has_default_price?,
-             :images, to: :find_or_build_master
+             :display_compare_at_price, :images, to: :find_or_build_master
 
     alias master_images images
 
@@ -160,10 +160,8 @@ module Spree
     #
     # @return [Spree::Variant]
     def default_variant
-      track_inventory = Spree::Config[:track_inventory_levels]
-
-      Rails.cache.fetch("spree/default-variant/#{cache_key_with_version}/#{track_inventory}") do
-        if track_inventory && variants.in_stock_or_backorderable.any?
+      Rails.cache.fetch(default_variant_cache_key) do
+        if Spree::Config[:track_inventory_levels] && variants.in_stock_or_backorderable.any?
           variants.in_stock_or_backorderable.first
         else
           has_variants? ? variants.first : master
@@ -252,6 +250,14 @@ module Spree
       where conditions.inject(:or)
     end
 
+    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
+
     # Suitable for displaying only variants that has at least one option value.
     # There may be scenarios where an option type is removed and along with it
     # all option values. At that point all variants associated with only those
@@ -341,7 +347,11 @@ module Spree
           price: master.price
         )
       end
-      throw(:abort) unless save
+      save
+    end
+
+    def default_variant_cache_key
+      "spree/default-variant/#{cache_key_with_version}/#{Spree::Config[:track_inventory_levels]}"
     end
 
     def ensure_master

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -23,7 +23,7 @@ module Spree
           order   = line_item.order
 
           # Prevent negative order totals
-          amounts << order.amount - order.adjustments.sum(:amount).abs if order.adjustments.any?
+          amounts << order.amount - order.adjustments.eligible.sum(:amount).abs if order.adjustments.eligible.any?
 
           amounts.min * -1
         end

data/app/models/spree/promotion_handler/coupon.rb

@@ -28,7 +28,7 @@ module Spree
 
         if promotion.present?
           # Order promotion has to be destroyed before line item removing
-          order.order_promotions.find_by!(promotion_id: promotion.id).destroy
+          order.order_promotions.where(promotion_id: promotion.id).destroy_all
 
           remove_promotion_adjustments(promotion)
           remove_promotion_line_items(promotion)

data/app/models/spree/reimbursement.rb

@@ -60,6 +60,8 @@ module Spree
     class_attribute :reimbursement_failure_hooks
     self.reimbursement_failure_hooks = []
 
+    delegate :store, :currency, to: :order
+
     state_machine :reimbursement_status, initial: :pending do
       event :errored do
         transition to: :errored, from: :pending

data/app/models/spree/shipment.rb

@@ -42,6 +42,8 @@ module Spree
     scope :reverse_chronological, -> { order(Arel.sql('coalesce(spree_shipments.shipped_at, spree_shipments.created_at) desc'), id: :desc) }
     scope :valid, -> { where.not(state: :canceled) }
 
+    delegate :store, :currency, to: :order
+
     # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine initial: :pending, use_transactions: false do
       event :ready do
@@ -104,11 +106,6 @@ module Spree
       inventory_units.any?(&:backordered?)
     end
 
-    # TODO: delegate currency to Order, order.currency is mandatory
-    def currency
-      order ? order.currency : Spree::Config[:currency]
-    end
-
     # Determines the appropriate +state+ according to the following logic:
     #
     # pending    unless order is complete and +order.payment_state+ is +paid+

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,23 @@ 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'
 
     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
+
     before_save :ensure_default_exists_and_is_unique
     before_destroy :validate_not_default
 
@@ -26,6 +37,12 @@ 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
+
     private
 
     def ensure_default_exists_and_is_unique

data/app/models/spree/taxon.rb

@@ -74,6 +74,12 @@ module Spree
       ancestor_chain + name.to_s
     end
 
+    def cached_self_and_descendants_ids
+      Rails.cache.fetch("#{cache_key_with_version}/descendant-ids") do
+        self_and_descendants.ids
+      end
+    end
+
     # awesome_nested_set sorts by :lft and :rgt. This call re-inserts the child
     # node so that its resulting position matches the observable 0-indexed position.
     # ** Note ** no :position column needed - a_n_s doesn't handle the reordering if

data/app/models/spree/variant.rb

@@ -48,7 +48,8 @@ module Spree
       validates :cost_price
       validates :price
     end
-    validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) }, case_sensitive: false }, allow_blank: true
+    validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) }, case_sensitive: false },
+                    allow_blank: true, unless: :disable_sku_validation?
 
     after_create :create_stock_items
     after_create :set_master_out_of_stock, unless: :is_master?
@@ -102,6 +103,20 @@ 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 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}%")
+    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?
       !discontinued? && product.available?
@@ -217,6 +232,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
@@ -226,7 +245,11 @@ module Spree
     end
 
     def in_stock?
-      Rails.cache.fetch(in_stock_cache_key) do
+      # 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
+      Rails.cache.fetch(in_stock_cache_key, version: version) do
         total_on_hand > 0
       end
     end
@@ -319,5 +342,9 @@ module Spree
     def clear_in_stock_cache
       Rails.cache.delete(in_stock_cache_key)
     end
+
+    def disable_sku_validation?
+      Spree::Config[:disable_sku_validation]
+    end
   end
 end

data/app/presenters/spree/variant_presenter.rb

@@ -16,6 +16,9 @@ module Spree
       @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 +74,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/checkout/get_shipping_rates.rb

@@ -7,9 +7,7 @@ module Spree
         run :reload_order
         run :ensure_shipping_address
         run :ensure_line_items_present
-        run :move_order_to_delivery_state
-        run :generate_shipping_rates
-        run :return_shipments
+        run :generate_or_return_shipping_rates
       end
 
       private
@@ -31,6 +29,11 @@ module Spree
         success(order: order)
       end
 
+      def generate_or_return_shipping_rates(order:)
+        generate_shipping_rates(order: order) if order.shipments.empty?
+        return_shipments(order: order)
+      end
+
       def generate_shipping_rates(order:)
         ApplicationRecord.transaction do
           order.create_proposed_shipments
@@ -42,13 +45,7 @@ module Spree
       end
 
       def return_shipments(order:)
-        success(order.shipments.includes([shipping_rates: :shipping_method]))
-      end
-
-      def move_order_to_delivery_state(order:)
-        Spree::Dependencies.checkout_next_service.constantize.call(order: order) until order.state == 'delivery'
-
-        success(order: order)
+        success(order.reload.shipments.includes([shipping_rates: :shipping_method]))
       end
     end
   end