solidus_core 2.9.6 → 2.11.0

data/app/models/spree/order_taxation.rb

@@ -25,12 +25,12 @@ module Spree
     # @return [void]
     def apply(taxes)
       @order.line_items.each do |item|
-        taxed_items = taxes.line_item_taxes.select { |i| i.item_id == item.id }
+        taxed_items = taxes.line_item_taxes.select { |element| element.item_id == item.id }
         update_adjustments(item, taxed_items)
       end
 
       @order.shipments.each do |item|
-        taxed_items = taxes.shipment_taxes.select { |i| i.item_id == item.id }
+        taxed_items = taxes.shipment_taxes.select { |element| element.item_id == item.id }
         update_adjustments(item, taxed_items)
       end
     end
@@ -74,7 +74,7 @@ module Spree
         label: tax_item.label,
         included: tax_item.included_in_price
       )
-      tax_adjustment.update_attributes!(amount: tax_item.amount)
+      tax_adjustment.update!(amount: tax_item.amount)
       tax_adjustment
     end
   end

data/app/models/spree/order_updater.rb

@@ -17,7 +17,7 @@ module Spree
     # object with callbacks (otherwise you will end up in an infinite recursion as the
     # associations try to save and then in turn try to call +update!+ again.)
     def update
-      @order.transaction do
+      order.transaction do
         update_item_count
         update_shipment_amounts
         update_totals
@@ -26,12 +26,17 @@ module Spree
           update_shipments
           update_shipment_state
         end
-        run_hooks
+        run_hooks if update_hooks.any?
+        Spree::Event.fire 'order_recalculated', order: order
         persist_totals
       end
     end
 
     def run_hooks
+      Spree::Deprecation.warn \
+        "This method is deprecated. Please run your hooks by subscribing " \
+        "to `order_recalculated` and/or `order_finalized` events instead, depending " \
+        " on when OrderUpdater#run_hooks was called.", caller(1)
       update_hooks.each { |hook| order.send hook }
     end
 
@@ -136,20 +141,16 @@ module Spree
     end
 
     def update_shipment_amounts
-      shipments.each do |shipment|
-        shipment.update_amounts
-      end
+      shipments.each(&:update_amounts)
     end
 
     # give each of the shipments a chance to update themselves
     def update_shipments
-      shipments.each do |shipment|
-        shipment.update_state
-      end
+      shipments.each(&:update_state)
     end
 
     def update_payment_total
-      order.payment_total = payments.completed.includes(:refunds).map { |payment| payment.amount - payment.refunds.sum(:amount) }.sum
+      order.payment_total = payments.completed.includes(:refunds).sum { |payment| payment.amount - payment.refunds.sum(:amount) }
     end
 
     def update_shipment_total
@@ -185,7 +186,7 @@ module Spree
     end
 
     def persist_totals
-      order.save!(validate: false)
+      order.save!(validate: Spree::Config.run_order_validations_on_order_updater)
     end
 
     def log_state_change(name)

data/app/models/spree/payment.rb

@@ -15,9 +15,9 @@ module Spree
     NON_RISKY_AVS_CODES = ['B', 'D', 'H', 'J', 'M', 'Q', 'T', 'V', 'X', 'Y'].freeze
     RISKY_AVS_CODES     = ['A', 'C', 'E', 'F', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'R', 'S', 'U', 'W', 'Z'].freeze
 
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :payments
-    belongs_to :source, polymorphic: true
-    belongs_to :payment_method, -> { with_deleted }, class_name: 'Spree::PaymentMethod', inverse_of: :payments
+    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :payments, optional: true
+    belongs_to :source, polymorphic: true, optional: true
+    belongs_to :payment_method, -> { with_discarded }, class_name: 'Spree::PaymentMethod', inverse_of: :payments, optional: true
 
     has_many :offsets, -> { offset_payment }, class_name: "Spree::Payment", foreign_key: :source_id
     has_many :log_entries, as: :source
@@ -47,7 +47,7 @@ module Spree
     default_scope -> { order(:created_at) }
 
     scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
-    scope :with_state, ->(s) { where(state: s.to_s) }
+    scope :with_state, ->(state) { where(state: state.to_s) }
     # "offset" is reserved by activerecord
     scope :offset_payment, -> { where("source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'") }
 
@@ -63,44 +63,7 @@ module Spree
     scope :store_credits, -> { where(source_type: Spree::StoreCredit.to_s) }
     scope :not_store_credits, -> { where(arel_table[:source_type].not_eq(Spree::StoreCredit.to_s).or(arel_table[:source_type].eq(nil))) }
 
-    # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine initial: :checkout do
-      # With card payments, happens before purchase or authorization happens
-      #
-      # Setting it after creating a profile and authorizing a full amount will
-      # prevent the payment from being authorized again once Order transitions
-      # to complete
-      event :started_processing do
-        transition from: [:checkout, :pending, :completed, :processing], to: :processing
-      end
-      # When processing during checkout fails
-      event :failure do
-        transition from: [:pending, :processing], to: :failed
-      end
-      # With card payments this represents authorizing the payment
-      event :pend do
-        transition from: [:checkout, :processing], to: :pending
-      end
-      # With card payments this represents completing a purchase or capture transaction
-      event :complete do
-        transition from: [:processing, :pending, :checkout], to: :completed
-      end
-      event :void do
-        transition from: [:pending, :processing, :completed, :checkout], to: :void
-      end
-      # when the card brand isnt supported
-      event :invalidate do
-        transition from: [:checkout], to: :invalid
-      end
-
-      after_transition do |payment, transition|
-        payment.state_changes.create!(
-          previous_state: transition.from,
-          next_state:     transition.to,
-          name:           'payment'
-        )
-      end
-    end
+    include ::Spree::Config.state_machines.payment
 
     # @return [String] this payment's response code
     def transaction_id
@@ -216,11 +179,11 @@ module Spree
     end
 
     def source_required?
-      payment_method.present? && payment_method.source_required?
+      !!payment_method&.source_required?
     end
 
     def profiles_supported?
-      payment_method.respond_to?(:payment_profiles_supported?) && payment_method.payment_profiles_supported?
+      !!payment_method.try(:payment_profiles_supported?)
     end
 
     def create_payment_profile
@@ -232,8 +195,8 @@ module Spree
       return if source.imported
 
       payment_method.create_profile(self)
-    rescue ActiveMerchant::ConnectionError => e
-      gateway_error e
+    rescue ActiveMerchant::ConnectionError => error
+      gateway_error error
     end
 
     def invalidate_old_payments
@@ -273,7 +236,7 @@ module Spree
       # type of payment getting refunded, hence the additional check
       # if the source is a store credit.
       if store_credit? && source.is_a?(Spree::StoreCredit)
-        source.update_attributes!({
+        source.update!({
           action: Spree::StoreCredit::ELIGIBLE_ACTION,
           action_amount: amount,
           action_authorization_code: response_code

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

@@ -29,9 +29,9 @@ module Spree
         # For payment methods already implemeting `try_void`
         if try_void_available?(payment.payment_method)
           if response = payment.payment_method.try_void(payment)
-            payment.send(:handle_void_response, response)
+            payment.handle_void_response(response)
           else
-            payment.refunds.create!(amount: payment.credit_allowed, reason: refund_reason)
+            payment.refunds.create!(amount: payment.credit_allowed, reason: refund_reason, perform_after_create: false).perform!
           end
         else
           # For payment methods not yet implemeting `try_void`
@@ -55,7 +55,7 @@ module Spree
           'Please implement a `try_void` method instead that returns a response object if void succeeds ' \
           'or `false|nil` if not. Solidus will refund the payment then.'
         response = payment.payment_method.cancel(payment.response_code)
-        payment.send(:handle_void_response, response)
+        payment.handle_void_response(response)
       end
     end
   end

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

@@ -46,26 +46,30 @@ module Spree
       # Takes the amount in cents to capture.
       # Can be used to capture partial amounts of a payment, and will create
       # a new pending payment record for the remaining amount to capture later.
-      def capture!(amount = nil)
+      def capture!(capture_amount = nil)
         return true if completed?
-        amount ||= money.money.cents
+        return false unless amount.positive?
+
+        capture_amount ||= money.money.cents
         started_processing!
         protect_from_connection_error do
           # Standard ActiveMerchant capture usage
           response = payment_method.capture(
-            amount,
+            capture_amount,
             response_code,
             gateway_options
           )
-          money = ::Money.new(amount, currency)
+          money = ::Money.new(capture_amount, currency)
           capture_events.create!(amount: money.to_d)
-          update_attributes!(amount: captured_amount)
+          update!(amount: captured_amount)
           handle_response(response, :complete, :failure)
         end
       end
 
       def void_transaction!
         return true if void?
+        return false unless amount.positive?
+
         protect_from_connection_error do
           if payment_method.payment_profiles_supported?
             # Gateways supporting payment profiles will need access to credit card object because this stores the payment profile information
@@ -117,6 +121,22 @@ module Spree
         options
       end
 
+      # The unique identifier to be passed in to the payment gateway
+      def gateway_order_id
+        "#{order.number}-#{number}"
+      end
+
+      def handle_void_response(response)
+        record_response(response)
+
+        if response.success?
+          self.response_code = response.authorization
+          void
+        else
+          gateway_error(response)
+        end
+      end
+
       private
 
       def process_authorization
@@ -182,43 +202,47 @@ module Spree
         end
       end
 
-      def handle_void_response(response)
-        record_response(response)
-
-        if response.success?
-          self.response_code = response.authorization
-          void
-        else
-          gateway_error(response)
-        end
-      end
-
       def record_response(response)
         log_entries.create!(details: response.to_yaml)
       end
 
       def protect_from_connection_error
           yield
-      rescue ActiveMerchant::ConnectionError => e
-          gateway_error(e)
+      rescue ActiveMerchant::ConnectionError => error
+          gateway_error(error)
       end
 
       def gateway_error(error)
-        if error.is_a? ActiveMerchant::Billing::Response
-          text = error.params['message'] || error.params['response_reason_text'] || error.message
-        elsif error.is_a? ActiveMerchant::ConnectionError
-          text = I18n.t('spree.unable_to_connect_to_gateway')
-        else
-          text = error.to_s
-        end
-        logger.error(I18n.t('spree.gateway_error'))
-        logger.error("  #{error.to_yaml}")
-        raise Core::GatewayError.new(text)
-      end
-
-      # The unique identifier to be passed in to the payment gateway
-      def gateway_order_id
-        "#{order.number}-#{number}"
+        message, log = case error
+                       when ActiveMerchant::Billing::Response
+                          [
+                            error.params['message'] || error.params['response_reason_text'] || error.message,
+                            basic_response_info(error)
+                          ]
+                        when ActiveMerchant::ConnectionError
+                          [I18n.t('spree.unable_to_connect_to_gateway')] * 2
+                        else
+                          [error.to_s, error]
+                        end
+
+        logger.error("#{I18n.t('spree.gateway_error')}: #{log}")
+        raise Core::GatewayError.new(message)
+      end
+
+      # The gateway response information without the params since the params
+      # can contain PII.
+      def basic_response_info(response)
+        {
+          message: response.message,
+          test: response.test,
+          authorization: response.authorization,
+          avs_result: response.avs_result,
+          cvv_result: response.cvv_result,
+          error_code: response.error_code,
+          emv_authorization: response.emv_authorization,
+          gateway_order_id: gateway_order_id,
+          order_number: order.number
+        }
       end
     end
   end

data/app/models/spree/payment_capture_event.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class PaymentCaptureEvent < Spree::Base
-    belongs_to :payment, class_name: 'Spree::Payment'
+    belongs_to :payment, class_name: 'Spree::Payment', optional: true
 
     def display_amount
       Spree::Money.new(amount, { currency: payment.currency })

data/app/models/spree/payment_method.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'discard'
 require 'spree/preferences/statically_configurable'
 
 module Spree
@@ -15,17 +14,17 @@ module Spree
     preference :server, :string, default: 'test'
     preference :test_mode, :boolean, default: true
 
-    acts_as_paranoid
-    include Spree::ParanoiaDeprecations
-
-    include Discard::Model
-    self.discard_column = :deleted_at
+    include Spree::SoftDeletable
 
     acts_as_list
 
     # @private
     def self.const_missing(name)
       if name == :DISPLAY
+        Spree::Deprecation.warn(
+          "#{self}::DISPLAY has been deprecated and will be removed in Solidus v3.",
+          caller
+        )
         const_set(:DISPLAY, [:both, :front_end, :back_end])
       else
         super
@@ -63,7 +62,7 @@ module Spree
           @human
         ].compact
         options = { scope: [:activerecord, :models], count: 1, default: defaults }.merge!(options.except(:default))
-        I18n.translate(defaults.shift, options)
+        I18n.translate(defaults.shift, **options)
       end
     end
 
@@ -93,8 +92,8 @@ module Spree
           else
             active.available_to_users.available_to_admin
           end
-        available_payment_methods.select do |p|
-          store.nil? || store.payment_methods.empty? || store.payment_methods.include?(p)
+        available_payment_methods.select do |payment|
+          store.nil? || store.payment_methods.empty? || store.payment_methods.include?(payment)
         end
       end
 
@@ -108,9 +107,9 @@ module Spree
         where(type: to_s, active: true).count > 0
       end
 
-      # @deprecated Use .with_deleted.find instead
+      # @deprecated Use .with_discarded.find instead
       def find_with_destroyed(*args)
-        Spree::Deprecation.warn "#{self}.find_with_destroyed is deprecated. Use #{self}.with_deleted.find instead"
+        Spree::Deprecation.warn "#{self}.find_with_destroyed is deprecated. Use #{self}.with_discarded.find instead"
         unscoped { find(*args) }
       end
     end
@@ -199,6 +198,9 @@ module Spree
     #     4. app/views/spree/admin/payments/source_views/_{partial_name}.html.erb
     #     The view that represents your payment method on orders in the backend
     #
+    #     5. app/views/spree/api/payments/source_views/_{partial_name}.json.jbuilder
+    #     The view that represents your payment method on orders through the api
+    #
     def partial_name
       deprecated_method_type_override || type.demodulize.underscore
     end

data/app/models/spree/payment_method/bogus_credit_card.rb

@@ -19,7 +19,7 @@ module Spree
       return if payment.source.has_payment_profile?
       # simulate the storage of credit card profile using remote service
       if success = VALID_CCS.include?(payment.source.number)
-        payment.source.update_attributes(gateway_customer_profile_id: generate_profile_id(success))
+        payment.source.update(gateway_customer_profile_id: generate_profile_id(success))
       end
     end
 

data/app/models/spree/payment_source.rb

@@ -4,7 +4,7 @@ module Spree
   class PaymentSource < Spree::Base
     self.abstract_class = true
 
-    belongs_to :payment_method
+    belongs_to :payment_method, optional: true
 
     has_many :payments, as: :source
     has_many :wallet_payment_sources, class_name: 'Spree::WalletPaymentSource', as: :payment_source, inverse_of: :payment_source

data/app/models/spree/preference.rb

@@ -3,5 +3,5 @@
 class Spree::Preference < Spree::Base
   serialize :value
 
-  validates :key, presence: true, uniqueness: { allow_blank: true }
+  validates :key, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
 end

data/app/models/spree/price.rb

@@ -1,19 +1,13 @@
 # frozen_string_literal: true
 
-require 'discard'
-
 module Spree
   class Price < Spree::Base
-    acts_as_paranoid
-    include Spree::ParanoiaDeprecations
-
-    include Discard::Model
-    self.discard_column = :deleted_at
+    include Spree::SoftDeletable
 
     MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
 
-    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', touch: true
-    belongs_to :country, class_name: "Spree::Country", foreign_key: "country_iso", primary_key: "iso"
+    belongs_to :variant, -> { with_discarded }, class_name: 'Spree::Variant', touch: true, optional: true
+    belongs_to :country, class_name: "Spree::Country", foreign_key: "country_iso", primary_key: "iso", optional: true
 
     delegate :product, to: :variant
     delegate :tax_rates, to: :variant