solidus_core 1.0.0.pre

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

@@ -0,0 +1,210 @@
+module Spree
+  class Payment < Spree::Base
+    module Processing
+      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.money.cents
+        started_processing!
+        protect_from_connection_error do
+          check_environment
+          # 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)
+          update_attributes!(amount: captured_amount)
+          handle_response(response, :complete, :failure)
+        end
+      end
+
+      def void_transaction!
+        return true if void?
+        protect_from_connection_error do
+          check_environment
+
+          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
+
+          handle_void_response(response)
+        end
+      end
+
+      def cancel!
+        response = payment_method.cancel(response_code)
+        handle_void_response(response)
+      end
+
+      def gateway_options
+        order.reload
+        options = { :email       => order.email,
+                    :customer    => order.email,
+                    :customer_id => order.user_id,
+                    :ip          => order.last_ip_address,
+                    # Need to pass in a unique identifier here to make some
+                    # payment gateways happy.
+                    #
+                    # For more information, please see Spree::Payment#set_unique_identifier
+                    :order_id    => gateway_order_id }
+
+        options.merge!({ :shipping => order.ship_total * 100,
+                         :tax      => order.additional_tax_total * 100,
+                         :subtotal => order.item_total * 100,
+                         :discount => order.promo_total * 100,
+                         :currency => currency })
+
+        options.merge!({ :billing_address  => order.bill_address.try(:active_merchant_hash),
+                        :shipping_address => order.ship_address.try(:active_merchant_hash) })
+
+        options
+      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
+          check_environment
+
+          response = payment_method.send(action, money.money.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 handle_void_response(response)
+        record_response(response)
+
+        if response.success?
+          self.response_code = response.authorization
+          self.void
+        else
+          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
+
+      # Saftey check to make sure we're not accidentally performing operations on a live gateway.
+      # Ex. When testing in staging environment with a copy of production data.
+      def check_environment
+        return if payment_method.environment == Rails.env
+        message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
+        raise Core::GatewayError.new(message)
+      end
+
+      # The unique identifier to be passed in to the payment gateway
+      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

@@ -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.rb

@@ -0,0 +1,79 @@
+module Spree
+  class PaymentMethod < Spree::Base
+    acts_as_paranoid
+    DISPLAY = [:both, :front_end, :back_end]
+    default_scope -> { where(deleted_at: nil) }
+
+    scope :production, -> { where(environment: 'production') }
+
+    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 self.available(display_on = 'both')
+      all.select do |p|
+        p.active &&
+        (p.display_on == display_on.to_s || p.display_on.blank?) &&
+        (p.environment == Rails.env || p.environment.blank?)
+      end
+    end
+
+    def self.active?
+      where(type: self.to_s, environment: Rails.env, active: true).count > 0
+    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?
+      is_a? Spree::PaymentMethod::StoreCredit
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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(*args)
+      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    end
+
+    def cancel(response); end
+
+    def void(*args)
+      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    end
+
+    def source_required?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+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.unable_to_find'), {}, {})
+      else
+        action = -> (store_credit) {
+          store_credit.authorize(
+            amount_in_cents / 100.0.to_d,
+            gateway_options[:currency],
+            action_originator: gateway_options[:originator]
+          )
+        }
+        handle_action_call(store_credit, action, :authorize)
+      end
+    end
+
+    def capture(amount_in_cents, auth_code, gateway_options = {})
+      action = -> (store_credit) {
+        store_credit.capture(
+          amount_in_cents / 100.0.to_d,
+          auth_code,
+          gateway_options[:currency],
+          action_originator: gateway_options[:originator]
+        )
+      }
+
+      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.find 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.unable_to_find'), {}, {})
+      else
+        capture(amount_in_cents, event.authorization_code, gateway_options)
+      end
+    end
+
+    def void(auth_code, gateway_options={})
+      action = -> (store_credit) {
+        store_credit.void(auth_code, action_originator: gateway_options[:originator])
+      }
+      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 = auth_or_capture_event(auth_code)
+      store_credit = store_credit_event.try(:store_credit)
+
+      if store_credit_event.nil? || store_credit.nil?
+        return false
+      elsif store_credit_event.capture_action?
+        store_credit.credit(store_credit_event.amount, auth_code, store_credit.currency)
+      elsif store_credit_event.authorization_action?
+        store_credit.void(auth_code)
+      else
+        return false
+      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.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.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
+
+    def auth_or_capture_event(auth_code)
+      capture_event = StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::CAPTURE_ACTION)
+      auth_event = StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::AUTHORIZE_ACTION)
+      return capture_event || auth_event
+    end
+  end
+end