spree_core 4.1.10 → 4.2.0.rc2

data/app/models/spree/option_type.rb

@@ -19,12 +19,18 @@ module Spree
 
     default_scope { order(:position) }
 
+    scope :filterable, -> { where(filterable: true) }
+
     accepts_nested_attributes_for :option_values, reject_if: ->(ov) { ov[:name].blank? || ov[:presentation].blank? }, allow_destroy: true
 
     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

@@ -22,7 +22,7 @@ module Spree
     money_methods :outstanding_balance, :item_total,           :adjustment_total,
                   :included_tax_total,  :additional_tax_total, :tax_total,
                   :shipment_total,      :promo_total,          :total,
-                  :cart_promo_total
+                  :cart_promo_total,    :pre_tax_item_amount,  :pre_tax_total
 
     alias display_ship_total display_shipment_total
     alias_attribute :ship_total, :shipment_total
@@ -174,7 +174,12 @@ module Spree
 
     # Sum of all line item amounts pre-tax
     def pre_tax_item_amount
-      line_items.to_a.sum(&:pre_tax_amount)
+      line_items.sum(:pre_tax_amount)
+    end
+
+    # Sum of all line item and shipment pre-tax
+    def pre_tax_total
+      pre_tax_item_amount + shipments.sum(:pre_tax_amount)
     end
 
     def shipping_discount
@@ -297,15 +302,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 +356,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 +648,13 @@ module Spree
         sum(:amount)
     end
 
+    def has_free_shipping?
+      shipment_adjustments.
+        joins(:promotion_action).
+        where(spree_adjustments: { eligible: true, source_type: 'Spree::PromotionAction' },
+              spree_promotion_actions: { type: 'Spree::Promotion::Actions::FreeShipping' }).exists?
+    end
+
     private
 
     def link_by_email
@@ -706,5 +720,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/order/address_book.rb

@@ -55,31 +55,18 @@ module Spree
       def update_or_create_address(attributes = {})
         return if attributes.blank?
 
-        attributes = attributes.select { |_k, v| v.present? }
+        attributes.transform_values! { |v| v == '' ? nil : v }
 
-        if user
-          address = user.addresses.build(attributes.except(:id)).check
-          return address if address.id
-        end
-
-        if attributes[:id]
-          address = Spree::Address.find(attributes[:id])
-          attributes.delete(:id)
+        default_address_scope = user ? user.addresses : ::Spree::Address
+        default_address = default_address_scope.find_by(id: attributes[:id])
 
-          if address&.editable?
-            address.update(attributes)
-            return address
-          else
-            attributes.delete(:id)
-          end
-        end
+        if default_address&.editable?
+          default_address.update(attributes)
 
-        unless attributes[:id]
-          address = Spree::Address.new(attributes)
-          address.save
+          return default_address
         end
 
-        address
+        ::Spree::Address.find_or_create_by(attributes.except(:id, :updated_at, :created_at))
       end
     end
   end

data/app/models/spree/order/payments.rb

@@ -32,7 +32,7 @@ module Spree
         end
 
         def pending_payments
-          payments.select(&:pending?)
+          payments.pending
         end
 
         def unprocessed_payments
@@ -52,7 +52,7 @@ module Spree
 
             payment.public_send(method)
 
-            if payment.completed? && payment_total != total
+            if payment.completed? && payment_total != total_without_pending_store_credits
               self.payment_total += payment.amount
             end
           end
@@ -60,6 +60,14 @@ module Spree
           result = !!Spree::Config[:allow_checkout_on_gateway_error]
           errors.add(:base, e.message) && (return result)
         end
+
+        # Pending store credits are not added to `self.payment_total`.
+        # It can cause a situation where the amount of the credit card payment reduced with store credits
+        # may be added twice to `self.payment_total` causing wrong `order.outstanding_balance`
+        # calculations and thus an incorrect payment state.
+        def total_without_pending_store_credits
+          total - payments.map { |p| p.amount if p.source.is_a?(Spree::StoreCredit) && p.pending? }.sum(&:to_f)
+        end
       end
     end
   end

data/app/models/spree/preferences/store.rb

@@ -6,7 +6,7 @@
 
 require 'singleton'
 
-DB_EXCEPTIONS = if defined? PG
+DB_EXCEPTIONS ||= if defined? PG
                   [PG::ConnectionBad, ActiveRecord::NoDatabaseError]
                 elsif defined? Mysql2
                   [Mysql2::Error::ConnectionError, ActiveRecord::NoDatabaseError]

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

@@ -113,17 +113,17 @@ module Spree
 
     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
@@ -344,6 +350,10 @@ module Spree
       save
     end
 
+    def default_variant_cache_key
+      "spree/default-variant/#{cache_key_with_version}/#{Spree::Config[:track_inventory_levels]}"
+    end
+
     def ensure_master
       return unless new_record?
 

data/app/models/spree/promotion.rb

@@ -28,6 +28,8 @@ module Spree
 
     before_save :normalize_blank_values
 
+    before_validation :normalize_code
+
     scope :coupons, -> { where.not(code: nil) }
     scope :advertised, -> { where(advertise: true) }
     scope :applied, lambda {
@@ -192,21 +194,10 @@ module Spree
     end
 
     def used_by?(user, excluded_orders = [])
-      [
-        :adjustments,
-        :line_item_adjustments,
-        :shipment_adjustments
-      ].any? do |adjustment_type|
-        user.orders.complete.joins(adjustment_type).where(
-          spree_adjustments: {
-            source_type: 'Spree::PromotionAction',
-            source_id: actions.map(&:id),
-            eligible: true
-          }
-        ).where.not(
-          id: excluded_orders.map(&:id)
-        ).any?
-      end
+      user.orders.complete.joins(:promotions).joins(:all_adjustments).
+        where.not(spree_orders: { id: excluded_orders.map(&:id) }).
+        where(spree_promotions: { id: id }).
+        where(spree_adjustments: { source_type: 'Spree::PromotionAction', eligible: true }).any?
     end
 
     private
@@ -227,6 +218,10 @@ module Spree
       end
     end
 
+    def normalize_code
+      self.code = code.strip if code.present?
+    end
+
     def match_all?
       match_policy == 'all'
     end

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

@@ -25,10 +25,9 @@ module Spree
 
       def remove(coupon_code)
         promotion = order.promotions.with_coupon_code(coupon_code)
-
         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)
@@ -76,7 +75,7 @@ module Spree
           line_item = order.find_line_item_by_variant(item.variant)
           next if line_item.blank?
 
-          Spree::Dependencies.cart_remove_item_service(order: order, item: item.variant, quantity: item.quantity)
+          Spree::Dependencies.cart_remove_item_service.constantize.call(order: order, item: item.variant, quantity: item.quantity)
         end
       end
 

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

@@ -1,15 +1,16 @@
 module Spree
   module PromotionHandler
     class PromotionDuplicator
-      def initialize(promotion)
+      def initialize(promotion, random_string: nil)
         @promotion = promotion
+        @random_string = random_string || generate_random_string(4)
       end
 
       def duplicate
         @new_promotion = @promotion.dup
-        @new_promotion.path = "#{@promotion.path}_new"
+        @new_promotion.path = "#{@promotion.path}_#{@random_string}"
         @new_promotion.name = "New #{@promotion.name}"
-        @new_promotion.code = "#{@promotion.code}_new"
+        @new_promotion.code = "#{@promotion.code}_#{@random_string}"
 
         ActiveRecord::Base.transaction do
           @new_promotion.save
@@ -33,6 +34,11 @@ module Spree
         end
       end
 
+      def generate_random_string(number)
+        charset = Array('A'..'Z') + Array('a'..'z')
+        Array.new(number) { charset.sample }.join
+      end
+
       def copy_actions
         @promotion.promotion_actions.each do |action|
           new_action = action.dup

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