spree_core 4.1.12 → 4.2.0.rc3

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/payment.rb

@@ -14,7 +14,7 @@ module Spree
 
     with_options inverse_of: :payments do
       belongs_to :order, class_name: 'Spree::Order', touch: true
-      belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+      belongs_to :payment_method, -> { with_deleted }, class_name: 'Spree::PaymentMethod'
     end
     belongs_to :source, polymorphic: true
 
@@ -195,14 +195,28 @@ module Spree
 
     def validate_source
       if source && !source.valid?
-        source.errors.each do |field, error|
-          field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
-          errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{error}")
+        if Rails::VERSION::STRING >= '6.1'
+          source.errors.map { |error| { field: error.attribute, message: error&.message } }.each do |err|
+            next if err[:field].blank? || err[:message].blank?
+
+            add_source_error(err[:field], err[:message])
+          end
+        else
+          source.errors.messages.each do |field, error|
+            next if field.blank? || error.empty?
+
+            add_source_error(field, error.first)
+          end
         end
       end
       !errors.present?
     end
 
+    def add_source_error(field, message)
+      field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
+      errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{message}")
+    end
+
     def profiles_supported?
       payment_method.respond_to?(:payment_profiles_supported?) && payment_method.payment_profiles_supported?
     end

data/app/models/spree/payment/processing.rb

@@ -163,8 +163,8 @@ module Spree
                else
                  error.to_s
                end
-        logger.error(Spree.t(:gateway_error))
-        logger.error("  #{error.to_yaml}")
+        Rails.logger.error(Spree.t(:gateway_error))
+        Rails.logger.error("  #{error.to_yaml}")
         raise Core::GatewayError, text
       end
 

data/app/models/spree/payment_method.rb

@@ -12,7 +12,7 @@ module Spree
 
     validates :name, presence: true
 
-    belongs_to :store
+    has_and_belongs_to_many :stores
 
     with_options dependent: :restrict_with_error do
       has_many :payments, class_name: 'Spree::Payment', inverse_of: :payment_method
@@ -79,9 +79,9 @@ module Spree
     end
 
     def available_for_store?(store)
-      return true if store.blank? || store_id.blank?
+      return true if store.blank?
 
-      store_id == store.id
+      store_ids.include?(store.id)
     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

@@ -6,7 +6,7 @@ module Spree
 
     MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
 
-    belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
+    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
 
     before_validation :ensure_currency
 
@@ -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,20 +34,33 @@ 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
 
-    # Remove variant default_scope `deleted_at: nil`
-    def variant
-      Spree::Variant.unscoped { super }
+    def display_compare_at_price_including_vat_for(price_options)
+      Spree::Money.new(compare_at_price_including_vat_for(price_options), currency: currency)
     end
 
     private

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?
 
@@ -401,8 +411,18 @@ module Spree
       # We call master.default_price here to ensure price is initialized.
       # Required to avoid Variant#check_price validation failing on create.
       unless master.default_price && master.valid?
-        master.errors.each do |att, error|
-          errors.add(att, error)
+        if Rails::VERSION::STRING >= '6.1'
+          master.errors.map { |error| { field: error.attribute, message: error&.message } }.each do |err|
+            next if err[:field].blank? || err[:message].blank?
+
+            errors.add(err[:field], err[:message])
+          end
+        else
+          master.errors.messages.each do |field, error|
+            next if field.blank? || error.empty?
+
+            errors.add(field, error.first)
+          end
         end
       end
     end

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/rules/product.rb

@@ -58,7 +58,8 @@ module Spree
         end
 
         def product_ids_string=(s)
-          self.product_ids = s.to_s.split(',').map(&:strip)
+          # check this
+          self.product_ids = s
         end
       end
     end

data/app/models/spree/promotion/rules/user.rb

@@ -22,7 +22,8 @@ module Spree
         end
 
         def user_ids_string=(s)
-          self.user_ids = s.to_s.split(',').map(&:strip)
+          # check this
+          self.user_ids = s
         end
       end
     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/refund.rb

@@ -61,14 +61,14 @@ module Spree
                  end
 
       unless response.success?
-        logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
+        Rails.logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
         text = response.params['message'] || response.params['response_reason_text'] || response.message
         raise Core::GatewayError, text
       end
 
       response
     rescue ActiveMerchant::ConnectionError => e
-      logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
+      Rails.logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
       raise Core::GatewayError, Spree.t(:unable_to_connect_to_gateway)
     end
 

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/return_item/eligibility_validator/default.rb

@@ -1,5 +1,3 @@
-require_relative 'r_m_a_required'
-
 module Spree
   class ReturnItem::EligibilityValidator::Default < Spree::ReturnItem::EligibilityValidator::BaseValidator
     class_attribute :permitted_eligibility_validators

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+
@@ -365,7 +362,7 @@ module Spree
         desired_shipment: shipment_to_transfer_to,
         variant: variant,
         quantity: quantity
-      ).run!
+      )
     end
 
     private

data/app/models/spree/shipping_method.rb

@@ -19,7 +19,7 @@ module Spree
                                      foreign_key: 'shipping_method_id'
     has_many :zones, through: :shipping_method_zones, class_name: 'Spree::Zone'
 
-    belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
+    belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory', optional: true
 
     validates :name, :display_on, presence: true
 
@@ -44,10 +44,6 @@ module Spree
         select { |c| c.to_s.constantize < Spree::ShippingCalculator }
     end
 
-    def tax_category
-      Spree::TaxCategory.unscoped { super }
-    end
-
     def available_to_display?(display_filter)
       (frontend? && display_filter == DISPLAY_ON_FRONT_END) ||
         (backend? && display_filter == DISPLAY_ON_BACK_END)