spree 0.9.4 → 0.10.0.beta

data/vendor/extensions/payment_gateway/lib/spree/payment_gateway.rb

@@ -1,73 +1,170 @@
 module Spree
   module PaymentGateway    
-    def authorize(amount)
-      gateway = payment_gateway       
+    
+    def self.included(base)
+      base.named_scope :with_payment_profile, :conditions => "gateway_customer_profile_id IS NOT NULL"
+    end
+    
+    def authorize(amount, payment)
       # ActiveMerchant is configured to use cents so we need to multiply order total by 100
-      response = gateway.authorize((amount * 100).to_i, self, gateway_options)      
-      gateway_error(response) unless response.success?
+      response = payment_gateway.authorize((amount * 100).round, self, gateway_options(payment))      
+      gateway_error_from_response(response) unless response.success?
       
-      # create a creditcard_payment for the amount that was authorized
-      creditcard_payment = checkout.order.creditcard_payments.create(:amount => 0, :creditcard => self)
       # create a transaction to reflect the authorization
-      creditcard_payment.creditcard_txns << CreditcardTxn.new(
+      save
+      payment.txns << CreditcardTxn.create(
         :amount => amount,
         :response_code => response.authorization,
-        :txn_type => CreditcardTxn::TxnType::AUTHORIZE
+        :txn_type => CreditcardTxn::TxnType::AUTHORIZE,
+        :avs_response => response.avs_result['code']
       )
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)      
     end
 
-    def capture(authorization)
-      gw = payment_gateway
-      response = gw.capture((authorization.amount * 100).to_i, authorization.response_code, minimal_gateway_options)
-      gateway_error(response) unless response.success?          
-      creditcard_payment = authorization.creditcard_payment
+    def capture(payment)
+      return unless transaction = authorization(payment)
+      if payment_gateway.payment_profiles_supported?
+        # Gateways supporting payment profiles will need access to creditcard object because this stores the payment profile information
+        # so supply the authorization itself as well as the creditcard, rather than just the authorization code
+        response = payment_gateway.capture(transaction, self, minimal_gateway_options(payment))
+      else
+        # Standard ActiveMerchant capture usage
+        response = payment_gateway.capture((transaction.amount * 100).round, transaction.response_code, minimal_gateway_options(payment))
+      end
+      gateway_error_from_response(response) unless response.success?          
+
       # create a transaction to reflect the capture
-      creditcard_payment.creditcard_txns << CreditcardTxn.new(
-        :amount => authorization.amount,
+      save
+      payment.txns << CreditcardTxn.create(
+        :amount => transaction.amount,
         :response_code => response.authorization,
         :txn_type => CreditcardTxn::TxnType::CAPTURE
       )
+      payment.finalize!
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)      
     end
 
-    def purchase(amount)
+    def purchase(amount, payment)
       #combined Authorize and Capture that gets processed by the ActiveMerchant gateway as one single transaction.
-      gateway = payment_gateway 
-      response = gateway.purchase((amount * 100).to_i, self, gateway_options) 
-      gateway_error(response) unless response.success?
-      
+      response = payment_gateway.purchase((amount * 100).round, self, gateway_options(payment)) 
       
-      # create a creditcard_payment for the amount that was purchased
-      creditcard_payment = checkout.order.creditcard_payments.create(:amount => amount, :creditcard => self)
+      gateway_error_from_response(response) unless response.success?
+
       # create a transaction to reflect the purchase
-      creditcard_payment.creditcard_txns << CreditcardTxn.new(
+      save
+      payment.txns << CreditcardTxn.create(
         :amount => amount,
         :response_code => response.authorization,
-        :txn_type => CreditcardTxn::TxnType::PURCHASE
+        :txn_type => CreditcardTxn::TxnType::PURCHASE,
+        :avs_response => response.avs_result['code']
       )
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error t(:unable_to_connect_to_gateway)
     end
+    
+    def void(payment)
+      return unless transaction = purchase_or_authorize_transaction_for_payment(payment)
+
+      if payment_gateway.payment_profiles_supported?
+        response = payment_gateway.credit((transaction.amount * 100).round, self, transaction.response_code, minimal_gateway_options(payment))
+      else
+        response = payment_gateway.void(transaction.response_code, minimal_gateway_options(payment))
+      end      
+      gateway_error_from_response(response) unless response.success?
 
-    def void
-=begin
-      authorization = find_authorization
-      response = payment_gateway.void(authorization.response_code, minimal_gateway_options)
-      gateway_error(response) unless response.success?
-      self.creditcard_txns.create(:amount => order.total, :response_code => response.authorization, :txn_type => CreditcardTxn::TxnType::CAPTURE)
-=end
+      # create a transaction to reflect the void
+      save
+      payment.txns << CreditcardTxn.create(
+        :amount => -transaction.amount,
+        :response_code => response.authorization,
+        :txn_type => CreditcardTxn::TxnType::VOID
+      )
+      payment.update_attribute(:amount, 0.00)
+      payment.finalize!
     end
+
+    def credit(payment, amount=nil)      
+      return unless transaction = purchase_or_authorize_transaction_for_payment(payment)
+
+      amount ||= payment.order.outstanding_credit
+      
+      if payment_gateway.payment_profiles_supported?
+        response = payment_gateway.credit((amount * 100).round, self, transaction.response_code, minimal_gateway_options(payment))
+      else
+        response = payment_gateway.credit((amount * 100).round, transaction.response_code, minimal_gateway_options(payment))
+      end
+      gateway_error_from_response(response) unless response.success?
+
+      # create a transaction to reflect the purchase
+      save
+      payment.txns << CreditcardTxn.create(
+        :amount => -amount,
+        :response_code => response.authorization,
+        :txn_type => CreditcardTxn::TxnType::CREDIT
+      )
+      payment.update_attribute(:amount, payment.amount - amount)
+      payment.order.update_totals!
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)      
+    end
+
+    # find the transaction associated with the original authorization/capture
+    def authorization(payment)
+      payment.txns.find(:first,
+                :conditions => ["type = 'CreditcardTxn' AND txn_type = ? AND response_code IS NOT NULL", CreditcardTxn::TxnType::AUTHORIZE.to_s],
+                :order => 'created_at DESC')
+    end
+
+    # find a transaction that can be used to void or credit
+    def purchase_or_authorize_transaction_for_payment(payment)
+      payment.txns.detect {|txn| [CreditcardTxn::TxnType::AUTHORIZE, CreditcardTxn::TxnType::PURCHASE].include?(txn.txn_type) and txn.response_code.present?}
+    end
+
+    def actions
+      %w{capture void credit}
+    end
+
+    def can_capture?(payment)
+      authorization(payment).present? &&
+      has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE, CreditcardTxn::TxnType::VOID)
+    end
+
+    def can_void?(payment)
+      has_transaction_of_types?(payment, CreditcardTxn::TxnType::AUTHORIZE, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE) &&
+      has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::VOID)
+    end
+
+    # Can only refund a captured transaction but if transaction hasn't been cleared by merchant, refund may still fail
+    def can_credit?(payment)
+      has_transaction_of_types?(payment, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE) && 
+      has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::VOID) and payment.order.credit_owed?
+    end
+
+    def has_payment_profile?
+      gateway_customer_profile_id.present?
+    end
+
+
     
-    def gateway_error(response)
+    def gateway_error_from_response(response)
       text = response.params['message'] || 
              response.params['response_reason_text'] ||
              response.message
+      gateway_error(text)
+    end
+    
+    def gateway_error(text)
       msg = "#{I18n.t('gateway_error')} ... #{text}"
       logger.error(msg)
       raise Spree::GatewayError.new(msg)
     end
         
-    def gateway_options
-      options = {:billing_address => generate_address_hash(checkout.bill_address), 
-                 :shipping_address => generate_address_hash(checkout.shipment.address)}
-      options.merge minimal_gateway_options
+    def gateway_options(payment)
+      options = {:billing_address  => generate_address_hash(payment.order.bill_address), 
+                 :shipping_address => generate_address_hash(payment.order.shipment.address)}
+      options.merge minimal_gateway_options(payment)
     end    
     
     # Generates an ActiveMerchant compatible address hash from one of Spree's address objects
@@ -80,35 +177,42 @@ module Spree
     # Generates a minimal set of gateway options.  There appears to be some issues with passing in 
     # a billing address when authorizing/voiding a previously captured transaction.  So omits these 
     # options in this case since they aren't necessary.  
-    def minimal_gateway_options
-      {:email => checkout.email, 
-       :customer => checkout.email, 
-       :ip => checkout.ip_address, 
-       :order_id => checkout.order.number,
-       :shipping => checkout.order.ship_total * 100,
-       :tax => checkout.order.tax_total * 100, 
-       :subtotal => checkout.order.item_total * 100}  
+    def minimal_gateway_options(payment)
+      {:email    => payment.order.email, 
+       :customer => payment.order.email, 
+       :ip       => payment.order.ip_address, 
+       :order_id => payment.order.number,
+       :shipping => payment.order.ship_total * 100,
+       :tax      => payment.order.tax_total * 100, 
+       :subtotal => payment.order.item_total * 100}  
     end
     
     def spree_cc_type
-      return "visa" if ENV['RAILS_ENV'] == "development" and Spree::Gateway::Config[:use_bogus]
+      return "visa" if ENV['RAILS_ENV'] == "development" 
       self.class.type?(number)
     end
 
-    # instantiates the selected gateway and configures with the options stored in the database
     def payment_gateway
-      return Spree::BogusGateway.new if ENV['RAILS_ENV'] == "development" and Spree::Gateway::Config[:use_bogus]
-
-      # retrieve gateway configuration from the database
-      gateway_config = GatewayConfiguration.find :first
-      config_options = {}
-      gateway_config.gateway_option_values.each do |option_value|
-        key = option_value.gateway_option.name.to_sym
-        config_options[key] = option_value.value
+      @payment_gateway ||= Gateway.current
+    end  
+    
+    # TODO: Want to do this after_save but there is a possible danger of infinite loop which number_changed? check is intended to prevent.
+    # Removed the check to number_changed? and relying on the !has_payment_profile? to not re-create if we have a profile
+    def create_payment_profile
+      return unless payment_gateway.payment_profiles_supported? and number and !has_payment_profile?
+      payment_gateway.create_profile(self, {})
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
+    end
+
+    private
+
+      def has_transaction_of_types?(payment, *types)
+        (payment.txns.map(&:txn_type) & types).any?
       end
-      gateway = gateway_config.gateway.clazz.constantize.new(config_options)
 
-      return gateway
-    end  
+      def has_no_transaction_of_types?(payment, *types)
+        (payment.txns.map(&:txn_type) & types).none?
+      end
   end
 end

data/vendor/extensions/payment_gateway/payment_gateway_extension.rb

@@ -1,6 +1,3 @@
-# Uncomment this if you reference any of your controllers in activate
-require_dependency 'application'
-
 class PaymentGatewayExtension < Spree::Extension
   version "1.0"
   description "Provides basic payment gateway functionality.  User specifies an ActiveMerchant compatible gateway 
@@ -13,6 +10,27 @@ class PaymentGatewayExtension < Spree::Extension
     Creditcard.class_eval do
       # add gateway methods to the creditcard so we can authorize, capture, etc.
       include Spree::PaymentGateway
-    end
+    end          
+    
+    silence_warnings { require 'active_merchant/billing/authorize_net_cim' }
+    
+		#register all payment methods
+		[
+			Gateway::Bogus,
+      Gateway::AuthorizeNet,
+			Gateway::AuthorizeNetCim,
+      Gateway::Linkpoint,
+			Gateway::PayPal,
+			Gateway::Protx,
+			Gateway::Beanstream,
+			PaymentMethod::Check
+    ].each{|gw|
+      begin
+        gw.register  
+      rescue Exception => e
+        $stderr.puts "Error registering gateway #{gw}: #{e}"
+      end
+    }
+
   end
 end

data/vendor/extensions/payment_gateway/public/javascripts/gateway.js

@@ -0,0 +1,13 @@
+$j(function() {                                                                    
+  var original_gtwy_type = $j('#gtwy-type').attr('value');
+  $j('div#gateway-settings-warning').hide();
+  $j('#gtwy-type').change(function() { 
+    if ($j('#gtwy-type').attr('value') == original_gtwy_type) {
+      $j('div.gateway-settings').show();
+      $j('div#gateway-settings-warning').hide();
+    } else {
+      $j('div.gateway-settings').hide();
+      $j('div#gateway-settings-warning').show();
+    }
+  });
+})

data/vendor/extensions/payment_gateway/spec/models/creditcard_spec.rb

@@ -5,20 +5,11 @@ describe CreditcardPayment do
   before(:each) do
     @creditcard = Creditcard.new
   end
-  fixtures :gateways, :gateway_configurations
+  fixtures :gateways
 
   describe "payment_gateway" do
     it "should exist" do
       @creditcard.respond_to?(:payment_gateway).should be_true
     end
-
-    it "should return an instance of Spree::BogusGateway in development mode" do
-      ENV["RAILS_ENV"] = "development"
-      @creditcard.payment_gateway.should be_an_instance_of(Spree::BogusGateway)
-    end
-
-    it "should set the ActiveMerchant gateway mode to :test unless in production mode" do
-      @creditcard.payment_gateway.should be_test
-    end
   end
 end

data/vendor/extensions/payment_gateway/test/mocks/authorize_net_cim_mock.rb

@@ -0,0 +1,59 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # ==== Mock Customer Information Manager (CIM) Gateway
+    class AuthorizeNetCimGateway < Gateway
+
+      class << self
+        attr_accessor :force_failure
+        def force_failure?
+          !! @force_failure
+        end
+      end
+
+
+      def create_customer_profile(options)
+        if self.class.force_failure?
+          params = {
+            "messages"=>{"result_code"=>"Error", "message"=>{"code"=>"E00039", "text"=>"A duplicate record with id 945184 already exists."}}, 
+          }
+          ActiveMerchant::Billing::Response.new(false, "Failed to create profile.", params)
+        else
+          params = {"messages"=> {
+            "result_code"=>"Ok", 
+            "message"=>{"code"=>"I00001", "text"=>"Successful."}},
+            "customer_payment_profile_id_list"=>{"numeric_string"=>"456"}, 
+            "ref_id"=>"1263245498", 
+            "customer_profile_id"=>"123", 
+            "customer_shipping_address_id_list"=>{"numeric_string"=>"789"}, 
+            "validation_direct_response_list"=>nil
+          }
+          ActiveMerchant::Billing::Response.new(true, "Successful.", params)
+        end
+      end
+
+      def create_customer_profile_transaction(options)
+        if self.class.force_failure?
+          params = {
+            "messages"=>{
+              "result_code"=>"Error", 
+              "message"=>{"code"=>"E00040", "text"=>"customerProfileId or customerPaymentProfileId not found."}
+            }
+          }
+          ActiveMerchant::Billing::Response.new(false, "Failed to create profile.", params)
+        else
+          params = {
+            "messages" => {
+              "result_code"=>"Ok", 
+              "message"=>{"code"=>"I00001", "text"=>"Successful."}
+            }
+          }
+          if options[:transaction][:type] == :auth_only
+            params["direct_response"] = {"approval_code"=>"XYZ", "purchase_order_number"=>"", "amount"=>"0.01", "transaction_type"=>"auth_only", "invoice_number"=>""}
+          end       
+          ActiveMerchant::Billing::Response.new(true, "Successful.", params, :authorization => '123456')
+        end
+      end
+
+    end
+  end
+end

data/vendor/extensions/payment_gateway/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+# Load the environment
+unless defined? SPREE_ROOT
+  ENV["RAILS_ENV"] = "test"
+  case
+  when ENV["SPREE_ENV_FILE"]
+    require File.dirname(ENV["SPREE_ENV_FILE"]) + "/boot"
+  when File.dirname(__FILE__) =~ %r{vendor/spree/vendor/extensions}
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../../../")}/config/boot"
+  else
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../")}/config/boot"
+  end
+end
+require "#{SPREE_ROOT}/test/test_helper"

data/vendor/extensions/payment_gateway/test/unit/authorize_net_cim_test.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class AuthorizeNetCimTest < Test::Unit::TestCase
+
+  def setup
+    @cim_gateway = ActiveMerchant::Billing::AuthorizeNetCimGateway.new(
+      :login => 'x',
+      :password => 'y'
+    )
+    @country = Factory(:country, :name => "United States", :iso_name => "UNITED STATES", :iso3 => "USA", :iso => "US", :numcode => 840)
+    @address = Factory(:address, 
+      :firstname => 'John',
+      :lastname => 'Doe',
+      :address1 => '1234 My Street',
+      :address2 => 'Apt 1',
+      :city =>  'Washington DC',
+      :zipcode => '20123',
+      :phone => '(555)555-5555',
+      :state_name => 'MD',
+      :country => @country
+    )
+    @address.save!
+
+    @creditcard = Factory(:creditcard, :verification_value => '123', :number => '4242424242424242', :month => 9, :year => Time.now.year + 1, :first_name => 'John', :last_name => 'Doe')
+    @checkout = Factory(:checkout, :bill_address => @address, :ship_address => @address)
+    @checkout.payments << Factory(:payment, :source => @creditcard)
+    @gateway = Gateway::AuthorizeNetCim.create!(:name => 'Authorize.net CIM Gateway')
+    @creditcard.reload
+    
+    @address_options = { 
+      :first_name => 'John',
+      :last_name => 'Doe',
+      :address1 => '1234 My Street',
+      :address2 => 'Apt 1',
+      :city     => 'Washington DC',
+      :state    => 'MD',
+      :zip      => '20123',
+      :country  => 'US',
+      :phone    => '(555)555-5555'
+    }
+  end
+
+  context "options_for_create_customer_profile" do
+    should "build correct options hash" do
+      expected_options = {:profile => { 
+        :payment_profiles => {
+          # :bill_to => @address_options,
+          :payment => {:credit_card => @creditcard}
+          },
+          # :ship_to_list => @address_options
+        }}
+
+      options = @gateway.send(:options_for_create_customer_profile, @creditcard, @creditcard.gateway_options(@checkout))
+      merchant_customer_id = options[:profile].delete(:merchant_customer_id)
+
+      assert_equal expected_options, options
+    end
+  end
+  
+  context "create_customer_profile" do
+    should "create a customer profile sucessfully" do
+      result = @gateway.send(:create_customer_profile, @creditcard, @creditcard.gateway_options(@checkout))
+      assert result.is_a?(Hash)
+      assert_equal "123", result[:customer_profile_id]
+    end
+    should "raise a gateway error if there is a problem creating profile" do
+      ActiveMerchant::Billing::AuthorizeNetCimGateway.force_failure = true
+      assert_raise(Spree::GatewayError) { @gateway.send(:create_customer_profile, @creditcard, @creditcard.gateway_options(@checkout)) }
+    end
+  end
+
+  context "authorize" do
+    setup do
+      @response = @gateway.authorize(500, @creditcard, @creditcard.gateway_options(@checkout))
+    end
+    should "return successfull Response object" do
+      assert @response.is_a?(ActiveMerchant::Billing::Response)
+      assert @response.success?
+    end
+    should "have authorization code in response" do
+      assert_equal '123456', @response.authorization
+    end
+  end
+
+end