solidus_core 1.0.0.pre

data/app/models/spree/order_stock_location.rb

@@ -0,0 +1,15 @@
+module Spree
+  class OrderStockLocation < ActiveRecord::Base
+    belongs_to :variant, class_name: "Spree::Variant"
+    belongs_to :stock_location, class_name: "Spree::StockLocation"
+    belongs_to :order, class_name: "Spree::Order"
+
+    def self.fulfill_for_order_with_stock_location(order, stock_location)
+      self.where(order_id: order.id, stock_location_id: stock_location.id).each(&:fulfill_shipment!)
+    end
+
+    def fulfill_shipment!
+      self.update_attributes!(shipment_fulfilled: true)
+    end
+  end
+end

data/app/models/spree/order_updater.rb

@@ -0,0 +1,178 @@
+module Spree
+  class OrderUpdater
+    attr_reader :order
+    delegate :payments, :line_items, :adjustments, :all_adjustments, :shipments, :update_hooks, :quantity, to: :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    # This is a multi-purpose method for processing logic related to changes in the Order.
+    # It is meant to be called from various observers so that the Order is aware of changes
+    # that affect totals and other values stored in the Order.
+    #
+    # This method should never do anything to the Order that results in a save call on the
+    # 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
+      update_item_count
+      update_totals
+      if order.completed?
+        update_payment_state
+        update_shipments
+        update_shipment_state
+      end
+      run_hooks
+      persist_totals
+    end
+
+    def run_hooks
+      update_hooks.each { |hook| order.send hook }
+    end
+
+    def recalculate_adjustments
+      all_adjustments.includes(:adjustable).map(&:adjustable).uniq.each { |adjustable| Spree::ItemAdjustments.new(adjustable).update }
+    end
+
+    # Updates the following Order total values:
+    #
+    # +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
+      update_payment_total
+      update_item_total
+      update_shipment_total
+      update_adjustment_total
+    end
+
+
+    # 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
+    end
+
+    def update_payment_total
+      order.payment_total = payments.completed.includes(:refunds).inject(0) { |sum, payment| sum + payment.amount - payment.refunds.sum(:amount) }
+    end
+
+    def update_shipment_total
+      order.shipment_total = shipments.sum(:cost)
+      update_order_total
+    end
+
+    def update_order_total
+      order.total = order.item_total + order.shipment_total + order.adjustment_total
+    end
+
+    def update_adjustment_total
+      recalculate_adjustments
+      order.adjustment_total = line_items.sum(:adjustment_total) +
+                               shipments.sum(:adjustment_total)  +
+                               adjustments.eligible.sum(:amount)
+      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
+
+    def update_item_count
+      order.item_count = quantity
+    end
+
+    def update_item_total
+      order.item_total = line_items.sum('price * quantity')
+      update_order_total
+    end
+
+    def persist_totals
+      order.update_columns(
+        payment_state: order.payment_state,
+        shipment_state: order.shipment_state,
+        item_total: order.item_total,
+        item_count: order.item_count,
+        adjustment_total: order.adjustment_total,
+        included_tax_total: order.included_tax_total,
+        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,
+      )
+    end
+
+    # Updates the +shipment_state+ attribute according to the following logic:
+    #
+    # shipped   when all Shipments are in the "shipped" state
+    # partial   when at least one Shipment has a state of "shipped" and there is another Shipment with a state other than "shipped"
+    #           or there are InventoryUnits associated with the order that have a state of "sold" but are not associated with a Shipment.
+    # ready     when all Shipments are in the "ready" state
+    # backorder when there is backordered inventory associated with an order
+    # pending   when all Shipments are in the "pending" state
+    #
+    # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_shipment_state
+      if order.backordered?
+        order.shipment_state = 'backorder'
+      else
+        # get all the shipment states for this order
+        shipment_states = shipments.states
+        if shipment_states.size > 1
+          # multiple shiment states means it's most likely partially shipped
+          order.shipment_state = 'partial'
+        else
+          # will return nil if no shipments are found
+          order.shipment_state = shipment_states.first
+          # TODO inventory unit states?
+          # if order.shipment_state && order.inventory_units.where(:shipment_id => nil).exists?
+          #   shipments exist but there are unassigned inventory units
+          #   order.shipment_state = 'partial'
+          # end
+        end
+      end
+
+      order.state_changed('shipment')
+      order.shipment_state
+    end
+
+    # Updates the +payment_state+ attribute according to the following logic:
+    #
+    # paid          when +payment_total+ is equal to +total+
+    # balance_due   when +payment_total+ is less than +total+
+    # credit_owed   when +payment_total+ is greater than +total+
+    # failed        when most recent payment is in the failed state
+    #
+    # 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 && order.outstanding_balance != 0
+        order.payment_state = 'failed'
+      elsif order.state == 'canceled' && order.payment_total == 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
+  end
+end

data/app/models/spree/payment.rb

@@ -0,0 +1,292 @@
+module Spree
+  class Payment < Spree::Base
+    include Spree::Payment::Processing
+
+    IDENTIFIER_CHARS    = (('A'..'Z').to_a + ('0'..'9').to_a - %w(0 1 I O)).freeze
+    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, class_name: 'Spree::PaymentMethod', inverse_of: :payments
+
+    has_many :offsets, -> { offset_payment }, class_name: "Spree::Payment", foreign_key: :source_id
+    has_many :log_entries, as: :source
+    has_many :state_changes, as: :stateful
+    has_many :capture_events, :class_name => 'Spree::PaymentCaptureEvent'
+    has_many :refunds, inverse_of: :payment
+
+    before_validation :validate_source, unless: :invalid?
+    before_create :set_unique_identifier
+
+    after_save :create_payment_profile, if: :profiles_supported?
+
+    # update the order totals, etc.
+    after_save :update_order
+
+    after_create :create_eligible_credit_event
+
+    # invalidate previously entered payments
+    after_create :invalidate_old_payments
+
+    attr_accessor :source_attributes, :request_env
+
+    after_initialize :build_source
+
+    validates :amount, numericality: true
+    validates :source, presence: true, if: :source_required?
+
+    default_scope -> { order("#{self.table_name}.created_at") }
+
+    scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
+    scope :with_state, ->(s) { where(state: s.to_s) }
+    # "offset" is reserved by activerecord
+    scope :offset_payment, -> { where("source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'") }
+
+    scope :checkout, -> { with_state('checkout') }
+    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)) }
+
+    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
+
+    # @return [String] this payment's response code
+    def transaction_id
+      response_code
+    end
+
+    # @return [String] this payment's currency
+    delegate :currency, to: :order
+
+    # @return [Spree::Money] this amount of this payment as money object
+    def money
+      Spree::Money.new(amount, { currency: currency })
+    end
+    alias display_amount money
+
+    # Sets the amount, parsing it based on i18n settings if it is a string.
+    #
+    # @param amount [BigDecimal, String] the desired new amount
+    def amount=(amount)
+      self[:amount] =
+        case amount
+        when String
+          separator = I18n.t('number.currency.format.separator')
+          number    = amount.delete("^0-9-#{separator}\.").tr(separator, '.')
+          number.to_d if number.present?
+        end || amount
+    end
+
+    # The total amount of the offsets (for old-style refunds) for this payment.
+    #
+    # @return [BigDecimal] the total amount of this payment's offsets
+    def offsets_total
+      offsets.pluck(:amount).sum
+    end
+
+    # The total amount this payment can be credited.
+    #
+    # @return [BigDecimal] the amount of this payment minus the offsets
+    #   (old-style refunds) and refunds
+    def credit_allowed
+      amount - (offsets_total.abs + refunds.sum(:amount))
+    end
+
+    # @return [Boolean] true when this payment can be credited
+    def can_credit?
+      credit_allowed > 0
+    end
+
+    # When this is a new record without a source, builds a new source based on
+    # this payment's payment method and associates it correctly.
+    #
+    # @see https://github.com/spree/spree/issues/981
+    def build_source
+      return unless new_record?
+      if source_attributes.present? && source.blank? && payment_method.try(:payment_source_class)
+        self.source = payment_method.payment_source_class.new(source_attributes)
+        self.source.payment_method_id = payment_method.id
+        self.source.user_id = self.order.user_id if self.order
+      end
+    end
+
+    # @return [Array<String>] the actions available on this payment
+    def actions
+      sa = source_actions
+      sa |= ["failure"] if processing?
+      sa
+    end
+
+    # @return [Object] the source of ths payment
+    def payment_source
+      res = source.is_a?(Payment) ? source.source : source
+      res || payment_method
+    end
+
+    # @return [Boolean] true when this payment is risky based on address
+    def is_avs_risky?
+      return false if avs_response.blank? || NON_RISKY_AVS_CODES.include?(avs_response)
+      return true
+    end
+
+    # @return [Boolean] true when this payment is risky based on cvv
+    def is_cvv_risky?
+      return false if cvv_response_code == "M"
+      return false if cvv_response_code.nil?
+      return false if cvv_response_message.present?
+      return true
+    end
+
+    # @return [BigDecimal] the total amount captured on this payment
+    def captured_amount
+      capture_events.sum(:amount)
+    end
+
+    # @return [BigDecimal] the total amount left uncaptured on this payment
+    def uncaptured_amount
+      amount - captured_amount
+    end
+
+    # @return [Boolean] true when the payment method exists and is a store credit payment method
+    def store_credit?
+      payment_method.try!(:store_credit?)
+    end
+
+    private
+
+      def source_actions
+        return [] unless payment_source and payment_source.respond_to? :actions
+        payment_source.actions.select { |action| !payment_source.respond_to?("can_#{action}?") or payment_source.send("can_#{action}?", self) }
+      end
+
+      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}")
+            self.errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{error}")
+          end
+        end
+        return !errors.present?
+      end
+
+      def source_required?
+        payment_method.present? && payment_method.source_required?
+      end
+
+      def profiles_supported?
+        payment_method.respond_to?(:payment_profiles_supported?) && payment_method.payment_profiles_supported?
+      end
+
+      def create_payment_profile
+        # Don't attempt to create on bad payments.
+        return if %w(invalid failed).include?(state)
+        # Payment profile cannot be created without source
+        return unless source
+        # Imported payments shouldn't create a payment profile.
+        return if source.imported
+
+        payment_method.create_profile(self)
+      rescue ActiveMerchant::ConnectionError => e
+        gateway_error e
+      end
+
+      def invalidate_old_payments
+        if !store_credit? && !['invalid', 'failed'].include?(state)
+          order.payments.checkout.where(payment_method: payment_method).where("id != ?", self.id).each do |payment|
+            payment.invalidate!
+          end
+        end
+      end
+
+      def update_order
+        if completed? || void?
+          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
+      # duplicate IDs. We *were* using the Order number, but that's set once and
+      # is unchanging. What we need is a unique identifier on a per-payment basis,
+      # and this is it. Related to #1998.
+      # See https://github.com/spree/spree/issues/1998#issuecomment-12869105
+      def set_unique_identifier
+        begin
+          self.identifier = generate_identifier
+        end while self.class.exists?(identifier: self.identifier)
+      end
+
+      def generate_identifier
+        Array.new(8){ IDENTIFIER_CHARS.sample }.join
+      end
+
+      def create_eligible_credit_event
+        # When cancelling an order, a payment with the negative amount
+        # of the payment total is created to refund the customer. That
+        # payment has a source of itself (Spree::Payment) no matter the
+        # 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!({
+            action: Spree::StoreCredit::ELIGIBLE_ACTION,
+            action_amount: amount,
+            action_authorization_code: response_code,
+          })
+        end
+      end
+
+  end
+end