goca-spree-core 3.1.14.rails.5.0

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

@@ -0,0 +1,175 @@
+module Spree
+  class Payment < Spree::Base
+    module Processing
+      extend ActiveSupport::Concern
+      included do
+        class_attribute :gateway_options_class
+        self.gateway_options_class = Spree::Payment::GatewayOptions
+      end
+
+      def process!
+        if payment_method && payment_method.auto_capture?
+          purchase!
+        else
+          authorize!
+        end
+      end
+
+      def authorize!
+        handle_payment_preconditions { process_authorization }
+      end
+
+      # Captures the entire amount of a payment.
+      def purchase!
+        handle_payment_preconditions { process_purchase }
+      end
+
+      # 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)
+        return true if completed?
+        amount ||= money.amount_in_cents
+        started_processing!
+        protect_from_connection_error do
+          # Standard ActiveMerchant capture usage
+          response = payment_method.capture(
+            amount,
+            response_code,
+            gateway_options
+          )
+          money = ::Money.new(amount, currency)
+          capture_events.create!(amount: money.to_f)
+          split_uncaptured_amount
+          handle_response(response, :complete, :failure)
+        end
+      end
+
+      def void_transaction!
+        return true if void?
+        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
+            # so supply the authorization itself as well as the credit card, rather than just the authorization code
+            response = payment_method.void(self.response_code, source, gateway_options)
+          else
+            # Standard ActiveMerchant void usage
+            response = payment_method.void(self.response_code, gateway_options)
+          end
+          record_response(response)
+
+          if response.success?
+            self.response_code = response.authorization
+            self.void
+          else
+            gateway_error(response)
+          end
+        end
+      end
+
+      def cancel!
+        response = payment_method.cancel(response_code)
+        handle_response(response, :void, :failure)
+      end
+
+      def gateway_options
+        order.reload
+        gateway_options_class.new(self).to_hash
+      end
+
+      private
+
+      def process_authorization
+        started_processing!
+        gateway_action(source, :authorize, :pend)
+      end
+
+      def process_purchase
+        started_processing!
+        result = gateway_action(source, :purchase, :complete)
+        # This won't be called if gateway_action raises a GatewayError
+        capture_events.create!(amount: amount)
+      end
+
+      def handle_payment_preconditions(&block)
+        unless block_given?
+          raise ArgumentError.new("handle_payment_preconditions must be called with a block")
+        end
+
+        if payment_method && payment_method.source_required?
+          if source
+            if !processing?
+              if payment_method.supports?(source) || token_based?
+                yield
+              else
+                invalidate!
+                raise Core::GatewayError.new(Spree.t(:payment_method_not_supported))
+              end
+            end
+          else
+            raise Core::GatewayError.new(Spree.t(:payment_processing_failed))
+          end
+        end
+      end
+
+      def gateway_action(source, action, success_state)
+        protect_from_connection_error do
+          response = payment_method.send(action, money.amount_in_cents,
+                                         source,
+                                         gateway_options)
+          handle_response(response, success_state, :failure)
+        end
+      end
+
+      def handle_response(response, success_state, failure_state)
+        record_response(response)
+
+        if response.success?
+          unless response.authorization.nil?
+            self.response_code = response.authorization
+            self.avs_response = response.avs_result['code']
+
+            if response.cvv_result
+              self.cvv_response_code = response.cvv_result['code']
+              self.cvv_response_message = response.cvv_result['message']
+            end
+          end
+          self.send("#{success_state}!")
+        else
+          self.send(failure_state)
+          gateway_error(response)
+        end
+      end
+
+      def record_response(response)
+        log_entries.create!(:details => response.to_yaml)
+      end
+
+      def protect_from_connection_error
+        begin
+          yield
+        rescue ActiveMerchant::ConnectionError => e
+          gateway_error(e)
+        end
+      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 = Spree.t(:unable_to_connect_to_gateway)
+        else
+          text = error.to_s
+        end
+        logger.error(Spree.t(:gateway_error))
+        logger.error("  #{error.to_yaml}")
+        raise Core::GatewayError.new(text)
+      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.rb

@@ -0,0 +1,276 @@
+module Spree
+  class Payment < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'P', letters: true, length: 7)
+
+    extend FriendlyId
+    friendly_id :number, slug_column: :number, use: :slugged
+
+    include Spree::Payment::Processing
+
+    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
+    INVALID_STATES      = %w(failed invalid).freeze
+
+    with_options inverse_of: :payments do
+      belongs_to :order, class_name: 'Spree::Order', touch: true
+      belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+    end
+    belongs_to :source, polymorphic: true
+
+    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
+
+    validates :payment_method, presence: true
+    before_validation :validate_source
+
+    after_save :create_payment_profile, if: :profiles_supported?
+
+    # update the order totals, etc.
+    after_save :update_order
+
+    # invalidate previously entered payments
+    after_create :invalidate_old_payments
+    after_create :create_eligible_credit_event
+
+    attr_accessor :source_attributes, :request_env
+
+    after_initialize :build_source
+
+    validates :amount, numericality: true
+
+    delegate :store_credit?, to: :payment_method, allow_nil: true
+    default_scope { order(: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: INVALID_STATES) }
+
+    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))) }
+
+    # transaction_id is much easier to understand
+    def transaction_id
+      response_code
+    end
+
+    delegate :currency, to: :order
+
+    # 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
+
+    def money
+      Spree::Money.new(amount, { currency: currency })
+    end
+    alias display_amount money
+
+    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
+
+    def offsets_total
+      offsets.pluck(:amount).sum
+    end
+
+    def credit_allowed
+      amount - (offsets_total.abs + refunds.sum(:amount))
+    end
+
+    def can_credit?
+      credit_allowed > 0
+    end
+
+    # 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
+
+    def 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 payment_source
+      res = source.is_a?(Payment) ? source.source : source
+      res || payment_method
+    end
+
+    def is_avs_risky?
+      return false if avs_response.blank? || NON_RISKY_AVS_CODES.include?(avs_response)
+      return true
+    end
+
+    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
+
+    def captured_amount
+      capture_events.sum(:amount)
+    end
+
+    def uncaptured_amount
+      amount - captured_amount
+    end
+
+    def editable?
+      checkout? || pending?
+    end
+
+    private
+
+    def has_invalid_state?
+      INVALID_STATES.include?(state)
+    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 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 has_invalid_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
+        unless has_invalid_state?
+          order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
+            payment.invalidate!
+          end
+        end
+      end
+
+      def split_uncaptured_amount
+        if uncaptured_amount > 0
+          order.payments.create! amount: uncaptured_amount,
+                                 avs_response: avs_response,
+                                 cvv_response_code: cvv_response_code,
+                                 cvv_response_message: cvv_response_message,
+                                 payment_method: payment_method,
+                                 response_code: response_code,
+                                 source: source,
+                                 state: 'pending'
+          update_attributes(amount: captured_amount)
+        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
+
+      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.
+        return unless store_credit? && source.is_a?(Spree::StoreCredit)
+
+        # creates the store credit event
+        source.update_attributes!({
+          action: Spree::StoreCredit::ELIGIBLE_ACTION,
+          action_amount: amount,
+          action_authorization_code: response_code,
+        })
+      end
+
+      def invalidate_old_payments
+        return if store_credit? # store credits shouldn't invalidate other payment types
+        order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
+          payment.invalidate! unless payment.store_credit?
+        end
+      end
+
+  end
+end

data/app/models/spree/payment_capture_event.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PaymentCaptureEvent < Spree::Base
+    belongs_to :payment, class_name: 'Spree::Payment'
+
+    def display_amount
+      Spree::Money.new(amount, { currency: payment.currency })
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Spree
+  class PaymentMethod::Check < PaymentMethod
+    def actions
+      %w{capture void}
+    end
+
+    # Indicates whether its possible to capture the payment
+    def can_capture?(payment)
+      ['checkout', 'pending'].include?(payment.state)
+    end
+
+    # Indicates whether its possible to void the payment.
+    def can_void?(payment)
+      payment.state != 'void'
+    end
+
+    def capture(*)
+      simulated_successful_billing_response
+    end
+
+    def cancel(*)
+      simulated_successful_billing_response
+    end
+
+    def void(*)
+      simulated_successful_billing_response
+    end
+
+    def source_required?
+      false
+    end
+
+    def credit(*)
+      simulated_successful_billing_response
+    end
+
+    private
+
+    def simulated_successful_billing_response
+      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Spree
+  class PaymentMethod::StoreCredit < PaymentMethod
+    def payment_source_class
+      ::Spree::StoreCredit
+    end
+
+    def can_capture?(payment)
+      ['checkout', 'pending'].include?(payment.state)
+    end
+
+    def can_void?(payment)
+      payment.pending?
+    end
+
+    def authorize(amount_in_cents, store_credit, gateway_options = {})
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+      else
+        action = -> (store_credit) do
+          store_credit.authorize(
+            amount_in_cents / 100.0.to_d,
+            gateway_options[:currency],
+            action_originator: gateway_options[:originator]
+          )
+        end
+        handle_action_call(store_credit, action, :authorize)
+      end
+    end
+
+    def capture(amount_in_cents, auth_code, gateway_options = {})
+      action = -> (store_credit) do
+        store_credit.capture(
+          amount_in_cents / 100.0.to_d,
+          auth_code,
+          gateway_options[:currency],
+          action_originator: gateway_options[:originator]
+        )
+      end
+      handle_action(action, :capture, auth_code)
+    end
+
+    def purchase(amount_in_cents, store_credit, gateway_options = {})
+      eligible_events = store_credit.store_credit_events.where(
+        amount: amount_in_cents / 100.0.to_d,
+        action: Spree::StoreCredit::ELIGIBLE_ACTION
+      )
+      event = eligible_events.detect do |eligible_event|
+        store_credit.store_credit_events.where(authorization_code: eligible_event.authorization_code).
+          where.not(action: Spree::StoreCredit::ELIGIBLE_ACTION).empty?
+      end
+
+      if event.blank?
+        ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+      else
+        capture(amount_in_cents, event.authorization_code, gateway_options)
+      end
+    end
+
+    def void(auth_code, gateway_options = {})
+      action = -> (store_credit) do
+        store_credit.void(auth_code, action_originator: gateway_options[:originator])
+      end
+      handle_action(action, :void, auth_code)
+    end
+
+    def credit(amount_in_cents, auth_code, gateway_options)
+      action = -> (store_credit) do
+        currency = gateway_options[:currency] || store_credit.currency
+        originator = gateway_options[:originator]
+
+        store_credit.credit(amount_in_cents / 100.0.to_d, auth_code, currency, action_originator: originator)
+      end
+
+      handle_action(action, :credit, auth_code)
+    end
+
+    def cancel(auth_code)
+      store_credit_event = StoreCreditEvent.find_by(authorization_code: auth_code,
+                                                    action: Spree::StoreCredit::CAPTURE_ACTION)
+      store_credit = store_credit_event.try(:store_credit)
+
+      if !store_credit_event || !store_credit
+        handle_action(nil, :cancel, false)
+      else
+        action = -> (store_credit) do
+          store_credit.credit(store_credit_event.amount, auth_code, store_credit.currency)
+        end
+        handle_action(action, :cancel, auth_code)
+      end
+    end
+
+    def source_required?
+      true
+    end
+
+    private
+
+    def handle_action_call(store_credit, action, action_name, auth_code = nil)
+      store_credit.with_lock do
+        if response = action.call(store_credit)
+          # note that we only need to return the auth code on an 'auth', but it's innocuous to always return
+          ActiveMerchant::Billing::Response.new(
+            true,
+            Spree.t('store_credit_payment_method.successful_action', action: action_name),
+            {},
+            authorization: auth_code || response
+          )
+        else
+          ActiveMerchant::Billing::Response.new(false, store_credit.errors.full_messages.join, {}, {})
+        end
+      end
+    end
+
+    def handle_action(action, action_name, auth_code)
+      # Find first event with provided auth_code
+      store_credit = StoreCreditEvent.find_by_authorization_code(auth_code).try(:store_credit)
+
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(
+          false,
+          Spree.t('store_credit_payment_method.unable_to_find_for_action', auth_code: auth_code, action: action_name),
+          {},
+          {}
+        )
+      else
+        handle_action_call(store_credit, action, action_name, auth_code)
+      end
+    end
+  end
+end

data/app/models/spree/payment_method.rb

@@ -0,0 +1,71 @@
+module Spree
+  class PaymentMethod < Spree::Base
+    acts_as_paranoid
+    acts_as_list
+
+    DISPLAY = [:both, :front_end, :back_end].freeze
+
+    scope :active,                 -> { where(active: true) }
+    scope :available,              -> { active.where(display_on: [:front_end, :back_end, :both]) }
+    scope :available_on_front_end, -> { active.where(display_on: [:front_end, :both]) }
+    scope :available_on_back_end,  -> { active.where(display_on: [:back_end, :both]) }
+
+    validates :name, presence: true
+
+    has_many :payments, class_name: "Spree::Payment", inverse_of: :payment_method
+    has_many :credit_cards, class_name: "Spree::CreditCard"
+
+    def self.providers
+      Rails.application.config.spree.payment_methods
+    end
+
+    def provider_class
+      raise ::NotImplementedError, 'You must implement provider_class method for this gateway.'
+    end
+
+    # The class that will process payments for this payment type, used for @payment.source
+    # e.g. CreditCard in the case of a the Gateway payment type
+    # nil means the payment method doesn't require a source e.g. check
+    def payment_source_class
+      raise ::NotImplementedError, 'You must implement payment_source_class method for this gateway.'
+    end
+
+    def method_type
+      type.demodulize.downcase
+    end
+
+    def self.find_with_destroyed *args
+      unscoped { find(*args) }
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def source_required?
+      true
+    end
+
+    # Custom gateways should redefine this method. See Gateway implementation
+    # as an example
+    def reusable_sources(order)
+      []
+    end
+
+    def auto_capture?
+      self.auto_capture.nil? ? Spree::Config[:auto_capture] : self.auto_capture
+    end
+
+    def supports?(source)
+      true
+    end
+
+    def cancel(response)
+      raise ::NotImplementedError, 'You must implement cancel method for this payment method.'
+    end
+
+    def store_credit?
+      self.class == Spree::PaymentMethod::StoreCredit
+    end
+  end
+end