spree_core 2.2.14 → 2.3.0

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

@@ -1,5 +1,5 @@
 module Spree
-  class Order < ActiveRecord::Base
+  class Order < Spree::Base
     module Checkout
       def self.included(klass)
         klass.class_eval do
@@ -71,7 +71,12 @@ module Spree
 
               if states[:payment]
                 before_transition :to => :complete do |order|
-                  order.process_payments! if order.payment_required?
+                  if order.payment_required? && order.payments.empty?
+                    order.errors.add(:base, Spree.t(:no_payment_found))
+                    false
+                  elsif order.payment_required?
+                    order.process_payments!
+                  end
                 end
               end
 
@@ -92,11 +97,9 @@ module Spree
                 before_transition :from => :delivery, :do => :apply_free_shipping_promotions
               end
 
-              before_transition to: :resumed, do: :ensure_line_items_are_in_stock
-
-              after_transition to: :complete, do: :finalize!
-              after_transition to: :resumed,  do: :after_resume
-              after_transition to: :canceled, do: :after_cancel
+              after_transition :to => :complete, :do => :finalize!
+              after_transition :to => :resumed,  :do => :after_resume
+              after_transition :to => :canceled, :do => :after_cancel
 
               after_transition :from => any - :cart, :to => any - [:confirm, :complete] do |order|
                 order.update_totals
@@ -206,11 +209,11 @@ module Spree
             checkout_step_index(state) > checkout_step_index(self.state)
           end
 
-          define_callbacks :updating_from_params, terminator: 'result == false'
+          define_callbacks :updating_from_params, terminator: ->(target, result) { result == false }
 
           set_callback :updating_from_params, :before, :update_params_payment_source
 
-          def update_from_params(params, permitted_params)
+          def update_from_params(params, permitted_params, request_env = {})
             success = false
             @updating_params = params
             run_callbacks :updating_from_params do
@@ -231,9 +234,13 @@ module Spree
                 attributes[:payments_attributes].first.delete :source_attributes
               end
 
+              if attributes[:payments_attributes]
+                attributes[:payments_attributes].first[:request_env] = request_env
+              end
+
               success = self.update_attributes(attributes)
-              set_shipments_cost if self.shipments.any?
             end
+
             @updating_params = nil
             success
           end

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

@@ -1,5 +1,5 @@
 module Spree
-  class Order < ActiveRecord::Base
+  class Order < Spree::Base
     module CurrencyUpdater
       extend ActiveSupport::Concern
 

data/app/models/spree/order_contents.rb

@@ -9,7 +9,6 @@ module Spree
     def add(variant, quantity = 1, currency = nil, shipment = nil)
       line_item = add_to_line_item(variant, quantity, currency, shipment)
       reload_totals
-      shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
       PromotionHandler::Cart.new(order, line_item).activate
       ItemAdjustments.new(line_item).update
       reload_totals
@@ -19,7 +18,6 @@ module Spree
     def remove(variant, quantity = 1, shipment = nil)
       line_item = remove_from_line_item(variant, quantity, shipment)
       reload_totals
-      shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
       PromotionHandler::Cart.new(order, line_item).activate
       ItemAdjustments.new(line_item).update
       reload_totals
@@ -49,7 +47,12 @@ module Spree
 
       def reload_totals
         order_updater.update_item_count
-        order_updater.update
+        order_updater.update_item_total
+        order_updater.update_adjustment_total
+
+        order_updater.update_payment_state if order.completed?
+        order_updater.persist_totals
+
         order.reload
       end
 
@@ -77,7 +80,7 @@ module Spree
 
       def remove_from_line_item(variant, quantity, shipment=nil)
         line_item = grab_line_item_by_variant(variant, true)
-        line_item.quantity += -quantity
+        line_item.quantity -= quantity
         line_item.target_shipment= shipment
 
         if line_item.quantity == 0

data/app/models/spree/order_populator.rb

@@ -9,9 +9,9 @@ module Spree
       @errors = ActiveModel::Errors.new(self)
     end
 
+    
     def populate(variant_id, quantity)
       attempt_cart_add(variant_id, quantity)
-      order.ensure_updated_shipments
       valid?
     end
 

data/app/models/spree/order_updater.rb

@@ -38,10 +38,9 @@ module Spree
     # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
     # +item_total+         The total value of all LineItems
     # +adjustment_total+   The total value of all adjustments (promotions, credits, etc.)
-    # +promo_total+        The total value of all promotion adjustments
     # +total+              The so-called "order total."  This is equivalent to +item_total+ plus +adjustment_total+.
     def update_totals
-      order.payment_total = payments.completed.sum(:amount)
+      update_payment_total
       update_item_total
       update_shipment_total
       update_adjustment_total
@@ -50,12 +49,11 @@ module Spree
 
     # give each of the shipments a chance to update themselves
     def update_shipments
-      shipments.each do |shipment|
-        next unless shipment.persisted?
-        shipment.update!(order)
-        shipment.refresh_rates
-        shipment.update_amounts
-      end
+      shipments.each { |shipment| shipment.update!(order) }
+    end
+
+    def update_payment_total
+      order.payment_total = payments.completed.sum(:amount)
     end
 
     def update_shipment_total
@@ -75,10 +73,6 @@ module Spree
       order.included_tax_total = line_items.sum(:included_tax_total) + shipments.sum(:included_tax_total)
       order.additional_tax_total = line_items.sum(:additional_tax_total) + shipments.sum(:additional_tax_total)
 
-      order.promo_total = line_items.sum(:promo_total) +
-                          shipments.sum(:promo_total) +
-                          adjustments.promotion.eligible.sum(:amount)
-
       update_order_total
     end
 
@@ -87,7 +81,7 @@ module Spree
     end
 
     def update_item_total
-      order.item_total = line_items.map(&:amount).sum
+      order.item_total = line_items.sum('price * quantity')
       update_order_total
     end
 
@@ -102,7 +96,6 @@ module Spree
         additional_tax_total: order.additional_tax_total,
         payment_total: order.payment_total,
         shipment_total: order.shipment_total,
-        promo_total: order.promo_total,
         total: order.total,
         updated_at: Time.now,
       )
@@ -152,23 +145,17 @@ module Spree
     # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
     def update_payment_state
       last_state = order.payment_state
-      if payments.present? && payments.valid.size == 0
+      if payments.present? && payments.last.state == 'failed'
         order.payment_state = 'failed'
-      elsif !payments.present? && order.state == 'canceled'
-        order.payment_state = 'void'
-      elsif order.state == 'canceled' && order.payment_total == 0 && payments.completed.size > 0
-        order.payment_state = 'void'
       else
         order.payment_state = 'balance_due' if order.outstanding_balance > 0
         order.payment_state = 'credit_owed' if order.outstanding_balance < 0
         order.payment_state = 'paid' if !order.outstanding_balance?
       end
       order.state_changed('payment') if last_state != order.payment_state
-      order.payment_state
     end
 
     private
-
       def round_money(n)
         (n * 100).round / 100.0
       end

data/app/models/spree/payment.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Payment < ActiveRecord::Base
+  class Payment < Spree::Base
     include Spree::Payment::Processing
 
     IDENTIFIER_CHARS    = (('A'..'Z').to_a + ('0'..'9').to_a - %w(0 1 I O)).freeze
@@ -8,7 +8,7 @@ module Spree
 
     belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :payments
     belongs_to :source, polymorphic: true
-    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', inverse_of: :payments
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
 
     has_many :offsets, -> { where("source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'") },
       class_name: "Spree::Payment", foreign_key: :source_id
@@ -26,13 +26,15 @@ module Spree
     # invalidate previously entered payments
     after_create :invalidate_old_payments
 
-    attr_accessor :source_attributes
+    attr_accessor :source_attributes, :request_env
+
     after_initialize :build_source
 
     scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
     scope :with_state, ->(s) { where(state: s.to_s) }
     scope :completed, -> { with_state('completed') }
     scope :pending, -> { with_state('pending') }
+    scope :processing, -> { with_state('processing') }
     scope :failed, -> { with_state('failed') }
     scope :risky, -> { where("avs_response IN (?) OR (cvv_response_code IS NOT NULL and cvv_response_code != 'M') OR state = 'failed'", RISKY_AVS_CODES) }
     scope :valid, -> { where.not(state: %w(failed invalid)) }
@@ -50,6 +52,10 @@ module Spree
     # 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
@@ -66,7 +72,7 @@ module Spree
         transition from: [:processing, :pending, :checkout], to: :completed
       end
       event :void do
-        transition from: [:pending, :completed, :checkout], to: :void
+        transition from: [:pending, :processing, :completed, :checkout], to: :void
       end
       # when the card brand isnt supported
       event :invalidate do
@@ -166,8 +172,7 @@ module Spree
       end
 
       def create_payment_profile
-        return unless source.respond_to?(:has_payment_profile?) && !source.has_payment_profile? &&
-          state != 'invalid' && state != 'failed'
+        return unless source.respond_to?(:has_payment_profile?) && !source.has_payment_profile?
 
         payment_method.create_profile(self)
       rescue ActiveMerchant::ConnectionError => e
@@ -175,16 +180,25 @@ module Spree
       end
 
       def invalidate_old_payments
-        if state != 'invalid' and state != 'failed'
-          order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
-            payment.invalidate!
-          end
+        order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
+          payment.invalidate!
         end
       end
 
       def update_order
-        order.payments.reload
-        order.update!
+        if self.completed?
+          order.updater.update_payment_total
+        end
+
+        if order.completed?
+          order.updater.update_payment_state
+          order.updater.update_shipments
+          order.updater.update_shipment_state
+        end
+
+        if self.completed? || order.completed?
+          order.persist_totals
+        end
       end
 
       # Necessary because some payment gateways will refuse payments with

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

@@ -1,11 +1,11 @@
 module Spree
-  class Payment < ActiveRecord::Base
+  class Payment < Spree::Base
     module Processing
       def process!
         if payment_method && payment_method.source_required?
           if source
             if !processing?
-              if payment_method.supports?(source) || token_based?
+              if payment_method.supports?(source)
                 if payment_method.auto_capture?
                   purchase!
                 else
@@ -81,17 +81,11 @@ module Spree
       end
 
       def credit!(credit_amount=nil)
-        raise Core::GatewayError.new(Spree.t(:payment_processing_failed)) if processing?
-
-        # Calculate credit amount before marking as processing since it messes up the order totals not having payment in completed state.
-        credit_amount ||= credit_allowed >= order.outstanding_balance.abs ? order.outstanding_balance.abs : credit_allowed.abs
-        credit_amount = credit_amount.to_f
-
-        # Mark as processing to avoid race condition that could send multiple credits to the gateway.
-        started_processing!
         protect_from_connection_error do
           check_environment
 
+          credit_amount ||= credit_allowed >= order.outstanding_balance.abs ? order.outstanding_balance.abs : credit_allowed.abs
+          credit_amount = credit_amount.to_f
           credit_cents = Spree::Money.new(credit_amount, currency: currency).money.cents
 
           if payment_method.payment_profiles_supported?
@@ -101,8 +95,6 @@ module Spree
           end
 
           record_response(response)
-          # Always set back to 'completed' as initial payment record was successful.
-          self.update_column(:state, 'completed')
 
           if response.success?
             self.class.create!(
@@ -129,6 +121,7 @@ module Spree
 
       def partial_credit(amount)
         return if amount > credit_allowed
+        started_processing!
         credit!(amount)
       end
 
@@ -226,10 +219,6 @@ module Spree
       def gateway_order_id
         "#{order.number}-#{self.identifier}"
       end
-
-      def token_based?
-        source.gateway_customer_profile_id.present? || source.gateway_payment_profile_id.present?
-      end
     end
   end
 end

data/app/models/spree/payment_capture_event.rb

@@ -1,5 +1,5 @@
 module Spree
-  class PaymentCaptureEvent < ActiveRecord::Base
+  class PaymentCaptureEvent < Spree::Base
     belongs_to :payment, class_name: 'Spree::Payment'
 
     def display_amount

data/app/models/spree/payment_method.rb

@@ -1,5 +1,5 @@
 module Spree
-  class PaymentMethod < ActiveRecord::Base
+  class PaymentMethod < Spree::Base
     acts_as_paranoid
     DISPLAY = [:both, :front_end, :back_end]
     default_scope -> { where(deleted_at: nil) }
@@ -8,7 +8,7 @@ module Spree
 
     validates :name, presence: true
 
-    has_many :payments, class_name: "Spree::Payment", inverse_of: :payment_method
+    has_many :payments, class_name: "Spree::Payment"
     has_many :credit_cards, class_name: "Spree::CreditCard"
 
     def self.providers

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

@@ -18,8 +18,6 @@ module Spree
       ActiveMerchant::Billing::Response.new(true, "", {}, {})
     end
 
-    def cancel(response); end
-
     def void(*args)
       ActiveMerchant::Billing::Response.new(true, "", {}, {})
     end

data/app/models/spree/preference.rb

@@ -1,35 +1,5 @@
-class Spree::Preference < ActiveRecord::Base
+class Spree::Preference < Spree::Base
   serialize :value
 
   validates :key, presence: true
-  validates :value_type, presence: true
-
-  scope :valid, -> { where(Spree::Preference.arel_table[:key].not_eq(nil)).where(Spree::Preference.arel_table[:value_type].not_eq(nil)) }
-
-  # The type conversions here should match
-  # the ones in spree::preferences::preferrable#convert_preference_value
-  def value
-    if self[:value_type].present?
-      case self[:value_type].to_sym
-      when :string, :text
-        self[:value].to_s
-      when :password
-        self[:value].to_s
-      when :decimal
-        BigDecimal.new(self[:value].to_s).round(2, BigDecimal::ROUND_HALF_UP)
-      when :integer
-        self[:value].to_i
-      when :boolean
-        (self[:value].to_s =~ /^[t|1]/i) != nil
-      else
-        self[:value].is_a?(String) ? YAML.load(self[:value]) : self[:value]
-      end
-    else
-      self[:value]
-    end
-  end
-
-  def raw_value
-    self[:value]
-  end
 end

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

@@ -28,12 +28,8 @@ module Spree::Preferences
       yield(self) if block_given?
     end
 
-    def preference_cache_key(name)
-      [rails_cache_id, self.class.name, name].compact.join('::').underscore
-    end
-
-    def rails_cache_id
-      ENV['RAILS_CACHE_ID']
+    def preferences
+      ScopedStore.new(self.class.name.underscore)
     end
 
     def reset

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

@@ -1,40 +1,47 @@
-# The preference_cache_key is used to determine if the preference
-# can be set. The default behavior is to return nil if there is no
-# id value. On ActiveRecords, new objects will have their preferences
-# saved to a pending hash until it is persisted.
+# Preferable allows defining preference accessor methods.
 #
-# class_attributes are inheritied unless you reassign them in
-# the subclass, so when you inherit a Preferable class, the
-# inherited hook will assign a new hash for the subclass definitions
-# and copy all the definitions allowing the subclass to add
-# additional defintions without affecting the base
+# A class including Preferable must implement #preferences which should return
+# an object responding to .fetch(key), []=(key, val), and .delete(key).
+#
+# The generated writer method performs typecasting before assignment into the
+# preferences object.
+#
+# Examples:
+#
+#   # Spree::Base includes Preferable and defines preferences as a serialized
+#   # column.
+#   class Settings < Spree::Base
+#     preference :color,       :string,  default: 'red'
+#     preference :temperature, :integer, default: 21
+#   end
+#
+#   s = Settings.new
+#   s.preferred_color # => 'red'
+#   s.preferred_temperature # => 21
+#
+#   s.preferred_color = 'blue'
+#   s.preferred_color # => 'blue'
+#
+#   # Typecasting is performed on assignment
+#   s.preferred_temperature = '24'
+#   s.preferred_color # => 24
+#
+#   # Modifications have been made to the .preferences hash
+#   s.preferences #=> {color: 'blue', temperature: 24}
+#
+#   # Save the changes. All handled by activerecord
+#   s.save!
 module Spree::Preferences::Preferable
+  extend ActiveSupport::Concern
 
-  def self.included(base)
-    base.class_eval do
-      extend Spree::Preferences::PreferableClassMethods
-
-      if respond_to?(:after_create)
-        after_create do |obj|
-          obj.save_pending_preferences
-        end
-      end
-
-      if respond_to?(:after_destroy)
-        after_destroy do |obj|
-          obj.clear_preferences
-        end
-      end
-
-    end
+  included do
+    extend Spree::Preferences::PreferableClassMethods
   end
 
   def get_preference(name)
     has_preference! name
     send self.class.preference_getter_method(name)
   end
-  alias :preferred :get_preference
-  alias :prefers? :get_preference
 
   def set_preference(name, value)
     has_preference! name
@@ -51,11 +58,6 @@ module Spree::Preferences::Preferable
     send self.class.preference_default_getter_method(name)
   end
 
-  def preference_description(name)
-    has_preference! name
-    send self.class.preference_description_getter_method(name)
-  end
-
   def has_preference!(name)
     raise NoMethodError.new "#{name} preference not defined" unless has_preference? name
   end
@@ -64,50 +66,26 @@ module Spree::Preferences::Preferable
     respond_to? self.class.preference_getter_method(name)
   end
 
-  def preferences
-    prefs = {}
-    methods.grep(/^prefers_.*\?$/).each do |pref_method|
-      prefs[pref_method.to_s.gsub(/prefers_|\?/, '').to_sym] = send(pref_method)
+  def defined_preferences
+    methods.grep(/\Apreferred_.*=\Z/).map do |pref_method|
+      pref_method.to_s.gsub(/\Apreferred_|=\Z/, '').to_sym
     end
-    prefs
   end
 
-  def prefers?(name)
-    get_preference(name)
-  end
-
-  def preference_cache_key(name)
-    return unless id
-    [rails_cache_id, self.class.name, name, id].compact.join('::').underscore
-  end
-
-  def rails_cache_id
-    ENV['RAILS_CACHE_ID']
-  end
-
-  def save_pending_preferences
-    return unless @pending_preferences
-    @pending_preferences.each do |name, value|
-      set_preference(name, value)
-    end
+  def default_preferences
+    Hash[
+      defined_preferences.map do |preference|
+        [preference, preference_default(preference)]
+      end
+    ]
   end
 
   def clear_preferences
-    preferences.keys.each {|pref| preference_store.delete preference_cache_key(pref)}
+    preferences.keys.each {|pref| preferences.delete pref}
   end
 
   private
 
-  def add_pending_preference(name, value)
-    @pending_preferences ||= {}
-    @pending_preferences[name] = value
-  end
-
-  def get_pending_preference(name)
-    return unless @pending_preferences
-    @pending_preferences[name]
-  end
-
   def convert_preference_value(value, type)
     case type
     when :string, :text
@@ -115,7 +93,7 @@ module Spree::Preferences::Preferable
     when :password
       value.to_s
     when :decimal
-      BigDecimal.new(value.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+      BigDecimal.new(value.to_s)
     when :integer
       value.to_i
     when :boolean
@@ -132,10 +110,4 @@ module Spree::Preferences::Preferable
       value
     end
   end
-
-  def preference_store
-    Spree::Preferences::Store.instance
-  end
-
 end
-