killbill 3.1.11 → 3.1.12

data/lib/killbill/gen/plugin-api/payment_transaction_info_plugin.rb

@@ -1,21 +1,22 @@
-###################################################################################
-#                                                                                 #
-#                   Copyright 2010-2013 Ning, Inc.                                #
-#                   Copyright 2014 The Billing Project, LLC                       #
-#                                                                                 #
-#      The Billing Project licenses this file to you under the Apache License,    #
-#      version 2.0 (the "License"); you may not use this file except in           #
-#      compliance with the License.  You may obtain a copy of the License at:     #
-#                                                                                 #
-#          http://www.apache.org/licenses/LICENSE-2.0                             #
-#                                                                                 #
-#      Unless required by applicable law or agreed to in writing, software        #
-#      distributed under the License is distributed on an "AS IS" BASIS, WITHOUT  #
-#      WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the  #
-#      License for the specific language governing permissions and limitations    #
-#      under the License.                                                         #
-#                                                                                 #
-###################################################################################
+#############################################################################################
+#                                                                                           #
+#                   Copyright 2010-2013 Ning, Inc.                                          #
+#                   Copyright 2014 Groupon, Inc.                                            #
+#                   Copyright 2014 The Billing Project, LLC                                 #
+#                                                                                           #
+#      The Billing Project licenses this file to you under the Apache License, version 2.0  #
+#      (the "License"); you may not use this file except in compliance with the             #
+#      License.  You may obtain a copy of the License at:                                   #
+#                                                                                           #
+#          http://www.apache.org/licenses/LICENSE-2.0                                       #
+#                                                                                           #
+#      Unless required by applicable law or agreed to in writing, software                  #
+#      distributed under the License is distributed on an "AS IS" BASIS, WITHOUT            #
+#      WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the            #
+#      License for the specific language governing permissions and limitations              #
+#      under the License.                                                                   #
+#                                                                                           #
+#############################################################################################
 
 
 #

data/lib/killbill/gen/plugin-api/require_gen.rb

@@ -1,21 +1,22 @@
-###################################################################################
-#                                                                                 #
-#                   Copyright 2010-2013 Ning, Inc.                                #
-#                   Copyright 2014 The Billing Project, LLC                       #
-#                                                                                 #
-#      The Billing Project licenses this file to you under the Apache License,    #
-#      version 2.0 (the "License"); you may not use this file except in           #
-#      compliance with the License.  You may obtain a copy of the License at:     #
-#                                                                                 #
-#          http://www.apache.org/licenses/LICENSE-2.0                             #
-#                                                                                 #
-#      Unless required by applicable law or agreed to in writing, software        #
-#      distributed under the License is distributed on an "AS IS" BASIS, WITHOUT  #
-#      WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the  #
-#      License for the specific language governing permissions and limitations    #
-#      under the License.                                                         #
-#                                                                                 #
-###################################################################################
+#############################################################################################
+#                                                                                           #
+#                   Copyright 2010-2013 Ning, Inc.                                          #
+#                   Copyright 2014 Groupon, Inc.                                            #
+#                   Copyright 2014 The Billing Project, LLC                                 #
+#                                                                                           #
+#      The Billing Project licenses this file to you under the Apache License, version 2.0  #
+#      (the "License"); you may not use this file except in compliance with the             #
+#      License.  You may obtain a copy of the License at:                                   #
+#                                                                                           #
+#          http://www.apache.org/licenses/LICENSE-2.0                                       #
+#                                                                                           #
+#      Unless required by applicable law or agreed to in writing, software                  #
+#      distributed under the License is distributed on an "AS IS" BASIS, WITHOUT            #
+#      WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the            #
+#      License for the specific language governing permissions and limitations              #
+#      under the License.                                                                   #
+#                                                                                           #
+#############################################################################################
 
 
 #

data/lib/killbill/helpers/active_merchant/active_record/models/payment_method.rb

@@ -48,6 +48,10 @@ module Killbill
             end
           end
 
+          def self.from_kb_account_id_and_token(token, kb_account_id, kb_tenant_id)
+            from_kb_account_id(kb_account_id, kb_tenant_id).where("token = #{@@quotes_cache[token]}")
+          end
+
           def self.from_kb_payment_method_id(kb_payment_method_id, kb_tenant_id)
             if kb_tenant_id.nil?
               payment_methods = where("kb_payment_method_id = #{@@quotes_cache[kb_payment_method_id]} AND kb_tenant_id is NULL AND is_deleted = #{@@quotes_cache[false]}")

data/lib/killbill/helpers/active_merchant/active_record/models/response.rb

@@ -14,40 +14,43 @@ module Killbill
 
           self.abstract_class = true
 
-          def self.from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, kb_tenant_id, response, extra_params = {}, model = Response)
+          @@quotes_cache = build_quotes_cache
+
+          def self.from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, response, extra_params = {}, model = Response)
             # Under high load, Rails sometimes fails to set timestamps. Unclear why...
             current_time = Time.now.utc
             model.new({
-                          :api_call                  => api_call,
-                          :kb_account_id             => kb_account_id,
-                          :kb_payment_id             => kb_payment_id,
-                          :kb_payment_transaction_id => kb_payment_transaction_id,
-                          :transaction_type          => transaction_type,
-                          :kb_tenant_id              => kb_tenant_id,
-                          :message                   => response.message,
-                          :authorization             => response.authorization,
-                          :fraud_review              => response.fraud_review?,
-                          :test                      => response.test?,
-                          :avs_result_code           => response.avs_result.kind_of?(::ActiveMerchant::Billing::AVSResult) ? response.avs_result.code : response.avs_result['code'],
-                          :avs_result_message        => response.avs_result.kind_of?(::ActiveMerchant::Billing::AVSResult) ? response.avs_result.message : response.avs_result['message'],
-                          :avs_result_street_match   => response.avs_result.kind_of?(::ActiveMerchant::Billing::AVSResult) ? response.avs_result.street_match : response.avs_result['street_match'],
-                          :avs_result_postal_match   => response.avs_result.kind_of?(::ActiveMerchant::Billing::AVSResult) ? response.avs_result.postal_match : response.avs_result['postal_match'],
-                          :cvv_result_code           => response.cvv_result.kind_of?(::ActiveMerchant::Billing::CVVResult) ? response.cvv_result.code : response.cvv_result['code'],
-                          :cvv_result_message        => response.cvv_result.kind_of?(::ActiveMerchant::Billing::CVVResult) ? response.cvv_result.message : response.cvv_result['message'],
-                          :success                   => response.success?,
-                          :created_at                => current_time,
-                          :updated_at                => current_time
+                          :api_call                     => api_call,
+                          :kb_account_id                => kb_account_id,
+                          :kb_payment_id                => kb_payment_id,
+                          :kb_payment_transaction_id    => kb_payment_transaction_id,
+                          :transaction_type             => transaction_type,
+                          :payment_processor_account_id => payment_processor_account_id,
+                          :kb_tenant_id                 => kb_tenant_id,
+                          :message                      => response.message,
+                          :authorization                => response.authorization,
+                          :fraud_review                 => response.fraud_review?,
+                          :test                         => response.test?,
+                          :avs_result_code              => response.avs_result.kind_of?(::ActiveMerchant::Billing::AVSResult) ? response.avs_result.code : response.avs_result['code'],
+                          :avs_result_message           => response.avs_result.kind_of?(::ActiveMerchant::Billing::AVSResult) ? response.avs_result.message : response.avs_result['message'],
+                          :avs_result_street_match      => response.avs_result.kind_of?(::ActiveMerchant::Billing::AVSResult) ? response.avs_result.street_match : response.avs_result['street_match'],
+                          :avs_result_postal_match      => response.avs_result.kind_of?(::ActiveMerchant::Billing::AVSResult) ? response.avs_result.postal_match : response.avs_result['postal_match'],
+                          :cvv_result_code              => response.cvv_result.kind_of?(::ActiveMerchant::Billing::CVVResult) ? response.cvv_result.code : response.cvv_result['code'],
+                          :cvv_result_message           => response.cvv_result.kind_of?(::ActiveMerchant::Billing::CVVResult) ? response.cvv_result.message : response.cvv_result['message'],
+                          :success                      => response.success?,
+                          :created_at                   => current_time,
+                          :updated_at                   => current_time
                       }.merge!(extra_params))
           end
 
-          def self.create_response_and_transaction(identifier, transaction_model, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, kb_tenant_id, gw_response, amount_in_cents, currency, extra_params = {}, model = Response)
+          def self.create_response_and_transaction(identifier, transaction_model, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, gw_response, amount_in_cents, currency, extra_params = {}, model = Response)
             response, transaction, exception = nil
 
             # Rails wraps all create/save calls in a transaction. To speed things up, create a single transaction for both rows.
             # This has a small gotcha in the unhappy path though (see below).
             transaction do
               # Save the response to our logs
-              response = from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, kb_tenant_id, gw_response, extra_params, model)
+              response = from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, gw_response, extra_params, model)
               response.save!(shared_activerecord_options)
 
               transaction = nil
@@ -58,19 +61,20 @@ module Killbill
                 begin
                   # Originally, we used response.send("build_#{identifier}_transaction"), but the ActiveRecord magic was adding
                   # about 20% overhead - instead, we now construct the transaction record manually
-                  transaction = transaction_model.new(:kb_account_id              => kb_account_id,
-                                                      :kb_tenant_id               => kb_tenant_id,
-                                                      :amount_in_cents            => amount_in_cents,
-                                                      :currency                   => currency,
-                                                      :api_call                   => api_call,
-                                                      :kb_payment_id              => kb_payment_id,
-                                                      :kb_payment_transaction_id  => kb_payment_transaction_id,
-                                                      :transaction_type           => transaction_type,
-                                                      :txn_id                     => txn_id,
-                                                      "#{identifier}_response_id" => response.id,
+                  transaction = transaction_model.new(:kb_account_id                => kb_account_id,
+                                                      :kb_tenant_id                 => kb_tenant_id,
+                                                      :amount_in_cents              => amount_in_cents,
+                                                      :currency                     => currency,
+                                                      :api_call                     => api_call,
+                                                      :kb_payment_id                => kb_payment_id,
+                                                      :kb_payment_transaction_id    => kb_payment_transaction_id,
+                                                      :transaction_type             => transaction_type,
+                                                      :payment_processor_account_id => payment_processor_account_id,
+                                                      :txn_id                       => txn_id,
+                                                      "#{identifier}_response_id"   => response.id,
                                                       # See Response#from_response
-                                                      :created_at                 => response.created_at,
-                                                      :updated_at                 => response.updated_at)
+                                                      :created_at                   => response.created_at,
+                                                      :updated_at                   => response.updated_at)
                   transaction.save!(shared_activerecord_options)
                 rescue => e
                   exception = e
@@ -109,6 +113,7 @@ module Killbill
             t_info_plugin.second_payment_reference_id = second_reference_id
 
             properties = []
+            properties << create_plugin_property('payment_processor_account_id', payment_processor_account_id)
             properties << create_plugin_property('message', message)
             properties << create_plugin_property('authorization', authorization)
             properties << create_plugin_property('fraudReview', fraud_review)
@@ -217,6 +222,32 @@ module Killbill
             prop.value = value
             prop
           end
+
+          class << self
+            [:kb_payment_id, :kb_payment_transaction_id].each do |attribute|
+              define_method("responses_from_#{attribute.to_s}") do |transaction_type, attribute_value, kb_tenant_id, how_many = :multiple|
+                if kb_tenant_id.nil?
+                  if transaction_type.nil?
+                    transactions = where("kb_tenant_id is NULL AND #{attribute.to_s} = ?", attribute_value).order(:created_at)
+                  else
+                    transactions = where("transaction_type = #{@@quotes_cache[transaction_type]} AND kb_tenant_id is NULL AND #{attribute.to_s} = #{@@quotes_cache[attribute_value]}").order(:created_at)
+                  end
+                else
+                  if transaction_type.nil?
+                    transactions = where("kb_tenant_id = #{@@quotes_cache[kb_tenant_id]} AND #{attribute.to_s} = #{@@quotes_cache[attribute_value]}").order(:created_at)
+                  else
+                    transactions = where("transaction_type = #{@@quotes_cache[transaction_type]} AND kb_tenant_id = #{@@quotes_cache[kb_tenant_id]} AND #{attribute.to_s} = #{@@quotes_cache[attribute_value]}").order(:created_at)
+                  end
+                end
+                if how_many == :single
+                  raise "Kill Bill #{attribute} = #{attribute_value} mapping to multiple plugin transactions" if transactions.size > 1
+                  transactions[0]
+                else
+                  transactions
+                end
+              end
+            end
+          end
         end
       end
     end

data/lib/killbill/helpers/active_merchant/active_record/models/streamy_result_set.rb

@@ -21,15 +21,27 @@ module Killbill
               # Optimization: bail out if no more results
               break if result.nil? || result.empty?
             end if @batch > 0
+          ensure
             # Make sure to return DB connections to the Pool
-            ::ActiveRecord::Base.connection.close
+            close_connection
           end
 
           def to_a
             super.to_a.flatten
           end
+
+          private
+
+          def close_connection
+            pool = ::ActiveRecord::Base.connection_pool
+            return unless pool.active_connection?
+
+            connection = ::ActiveRecord::Base.connection
+            pool.remove(connection)
+            connection.disconnect!
+          end
         end
       end
     end
   end
-end
+end

data/lib/killbill/helpers/active_merchant/active_record/models/transaction.rb

@@ -41,11 +41,15 @@ module Killbill
               transaction_from_kb_payment_transaction_id(nil, kb_payment_transaction_id, kb_tenant_id, :single)
             end
 
-            def find_candidate_transaction_for_refund(kb_payment_id, kb_tenant_id, amount_in_cents)
-              begin
-                do_find_candidate_transaction_for_refund(:authorize, kb_payment_id, kb_tenant_id, amount_in_cents)
-              rescue
-                do_find_candidate_transaction_for_refund(:purchase, kb_payment_id, kb_tenant_id, amount_in_cents)
+            def find_candidate_transaction_for_refund(kb_payment_id, kb_tenant_id, amount_in_cents, transaction_type = nil)
+              if transaction_type.nil?
+                begin
+                  do_find_candidate_transaction_for_refund(:authorize, kb_payment_id, kb_tenant_id, amount_in_cents)
+                rescue
+                  do_find_candidate_transaction_for_refund(:purchase, kb_payment_id, kb_tenant_id, amount_in_cents)
+                end
+              else
+                do_find_candidate_transaction_for_refund(transaction_type, kb_payment_id, kb_tenant_id, amount_in_cents)
               end
             end
 

data/lib/killbill/helpers/active_merchant/killbill_spec_helper.rb

@@ -3,7 +3,7 @@ module Killbill
     module ActiveMerchant
       module RSpec
 
-        def create_payment_method(payment_method_model=::Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod, kb_account_id=nil, kb_tenant_id=nil)
+        def create_payment_method(payment_method_model=::Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod, kb_account_id=nil, kb_tenant_id=nil, properties = [], options = {})
           kb_payment_method_id = SecureRandom.uuid
 
           if kb_account_id.nil?
@@ -13,20 +13,20 @@ module Killbill
             create_kb_account kb_account_id
           end
 
-          context = @plugin.kb_apis.create_context(kb_tenant_id)
-          account = @plugin.kb_apis.account_user_api.get_account_by_id(kb_account_id, context)
+          context       = @plugin.kb_apis.create_context(kb_tenant_id)
+          account       = @plugin.kb_apis.account_user_api.get_account_by_id(kb_account_id, context)
 
           # The rest is pure Ruby
-          context = context.to_ruby(context)
+          context       = context.to_ruby(context)
 
           # Generate a token
-          properties = build_pm_properties(account)
+          pm_properties = build_pm_properties(account, options)
 
           info            = Killbill::Plugin::Model::PaymentMethodPlugin.new
-          info.properties = properties
-          payment_method  = @plugin.add_payment_method(kb_account_id, kb_payment_method_id, info, true, [], context)
+          info.properties = pm_properties
+          payment_method  = @plugin.add_payment_method(kb_account_id, kb_payment_method_id, info, true, properties, context)
 
-          pm = payment_method_model.from_kb_payment_method_id kb_payment_method_id, context.tenant_id
+          pm = payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
           pm.should == payment_method
           pm.kb_account_id.should == kb_account_id
           pm.kb_payment_method_id.should == kb_payment_method_id
@@ -34,21 +34,21 @@ module Killbill
           pm
         end
 
-        def build_pm_properties(account = nil)
-          cc_number             = '4242424242424242'
-          cc_first_name         = 'John'
-          cc_last_name          = 'Doe'
-          cc_type               = 'Visa'
-          cc_exp_month          = 12
-          cc_exp_year           = 2017
-          cc_last_4             = 4242
-          address1              = '5, oakriu road'
-          address2              = 'apt. 298'
-          city                  = 'Gdio Foia'
-          state                 = 'FL'
-          zip                   = 49302
-          country               = 'US'
-          cc_verification_value = 1234
+        def build_pm_properties(account = nil, overrides = {})
+          cc_number             = (overrides.delete(:cc_number) || '4242424242424242')
+          cc_first_name         = (overrides.delete(:cc_first_name) || 'John')
+          cc_last_name          = (overrides.delete(:cc_last_name) || 'Doe')
+          cc_type               = (overrides.delete(:cc_type) || 'Visa')
+          cc_exp_month          = (overrides.delete(:cc_exp_month) || 12)
+          cc_exp_year           = (overrides.delete(:cc_exp_year) || 2017)
+          cc_last_4             = (overrides.delete(:cc_last_4) || 4242)
+          address1              = (overrides.delete(:address1) || '5, oakriu road')
+          address2              = (overrides.delete(:address2) || 'apt. 298')
+          city                  = (overrides.delete(:city) || 'Gdio Foia')
+          state                 = (overrides.delete(:state) || 'FL')
+          zip                   = (overrides.delete(:zip) || 49302)
+          country               = (overrides.delete(:country) || 'US')
+          cc_verification_value = (overrides.delete(:cc_verification_value) || 1234)
 
           properties = []
           properties << create_pm_kv_info('ccNumber', cc_number)
@@ -66,6 +66,11 @@ module Killbill
           properties << create_pm_kv_info('zip', zip)
           properties << create_pm_kv_info('country', country)
           properties << create_pm_kv_info('ccVerificationValue', cc_verification_value)
+
+          overrides.each do |key, value|
+            properties << create_pm_kv_info(key, value)
+          end
+
           properties
         end
 

data/lib/killbill/helpers/active_merchant/payment_plugin.rb

@@ -1,9 +1,11 @@
 module Killbill
   module Plugin
     module ActiveMerchant
+      require 'active_merchant'
       require 'active_record'
       require 'monetize'
       require 'money'
+      require 'offsite_payments'
 
       class PaymentPlugin < ::Killbill::Plugin::Payment
 
@@ -44,7 +46,7 @@ module Killbill
         end
 
         def authorize_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+          gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
             gateway.authorize(amount_in_cents, payment_source, options)
           end
 
@@ -52,18 +54,22 @@ module Killbill
         end
 
         def capture_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+          gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
+            gateway.capture(amount_in_cents, linked_transaction.txn_id, options)
+          end
+
+          linked_transaction_proc = Proc.new do |amount_in_cents, options|
             # TODO We use the last transaction at the moment, is it good enough?
             last_authorization = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last
             raise "Unable to retrieve last authorization for operation=capture, kb_payment_id=#{kb_payment_id}, kb_payment_transaction_id=#{kb_payment_transaction_id}, kb_payment_method_id=#{kb_payment_method_id}" if last_authorization.nil?
-            gateway.capture(amount_in_cents, last_authorization.txn_id, options)
+            last_authorization
           end
 
-          dispatch_to_gateways(:capture, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
+          dispatch_to_gateways(:capture, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc, linked_transaction_proc)
         end
 
         def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+          gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
             gateway.purchase(amount_in_cents, payment_source, options)
           end
 
@@ -71,31 +77,41 @@ module Killbill
         end
 
         def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
-          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
-            # If an authorization is being voided, we're performing an 'auth_reversal', otherwise,
-            # we're voiding an unsettled capture or purchase (which often needs to happen within 24 hours).
-            last_transaction = @transaction_model.purchases_from_kb_payment_id(kb_payment_id, context.tenant_id).last
-            if last_transaction.nil?
-              last_transaction = @transaction_model.captures_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+          gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
+            authorization = linked_transaction.txn_id
+
+            # Go to the gateway - while some gateways implementations are smart and have void support 'auth_reversal' and 'void' (e.g. Litle),
+            # others (e.g. CyberSource) implement different methods
+            linked_transaction.transaction_type == 'AUTHORIZE' && gateway.respond_to?(:auth_reversal) ? gateway.auth_reversal(linked_transaction.amount_in_cents, authorization, options) : gateway.void(authorization, options)
+          end
+
+          linked_transaction_proc = Proc.new do |amount_in_cents, options|
+            linked_transaction_type = find_value_from_properties(properties, :linked_transaction_type)
+            if linked_transaction_type.nil?
+              # Default behavior to search for the last transaction
+              # If an authorization is being voided, we're performing an 'auth_reversal', otherwise,
+              # we're voiding an unsettled capture or purchase (which often needs to happen within 24 hours).
+              last_transaction = @transaction_model.purchases_from_kb_payment_id(kb_payment_id, context.tenant_id).last
               if last_transaction.nil?
-                last_transaction = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+                last_transaction = @transaction_model.captures_from_kb_payment_id(kb_payment_id, context.tenant_id).last
                 if last_transaction.nil?
-                  raise ArgumentError.new("Kill Bill payment #{kb_payment_id} has no auth, capture or purchase, thus cannot be voided")
+                  last_transaction = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+                  if last_transaction.nil?
+                    raise ArgumentError.new("Kill Bill payment #{kb_payment_id} has no auth, capture or purchase, thus cannot be voided")
+                  end
                 end
               end
+            else
+              last_transaction = @transaction_model.send("#{linked_transaction_type.to_s}s_from_kb_payment_id", kb_payment_id, context.tenant_id).last
             end
-            authorization = last_transaction.txn_id
-
-            # Go to the gateway - while some gateways implementations are smart and have void support 'auth_reversal' and 'void' (e.g. Litle),
-            # others (e.g. CyberSource) implement different methods
-            last_transaction.transaction_type == 'AUTHORIZE' && gateway.respond_to?(:auth_reversal) ? gateway.auth_reversal(last_transaction.amount_in_cents, authorization, options) : gateway.void(authorization, options)
+            last_transaction
           end
 
-          dispatch_to_gateways(:void, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, nil, nil, properties, context, gateway_call_proc)
+          dispatch_to_gateways(:void, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, nil, nil, properties, context, gateway_call_proc, linked_transaction_proc)
         end
 
         def credit_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+          gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
             gateway.credit(amount_in_cents, payment_source, options)
           end
 
@@ -103,13 +119,18 @@ module Killbill
         end
 
         def refund_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
-            transaction = @transaction_model.find_candidate_transaction_for_refund(kb_payment_id, context.tenant_id, amount_in_cents)
-            raise "Unable to retrieve transaction to refund for operation=capture, kb_payment_id=#{kb_payment_id}, kb_payment_transaction_id=#{kb_payment_transaction_id}, kb_payment_method_id=#{kb_payment_method_id}" if transaction.nil?
-            gateway.refund(amount_in_cents, transaction.txn_id, options)
+          gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
+            gateway.refund(amount_in_cents, linked_transaction.txn_id, options)
           end
 
-          dispatch_to_gateways(:refund, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
+          linked_transaction_proc = Proc.new do |amount_in_cents, options|
+            linked_transaction_type = find_value_from_properties(properties, :linked_transaction_type)
+            transaction             = @transaction_model.find_candidate_transaction_for_refund(kb_payment_id, context.tenant_id, amount_in_cents, linked_transaction_type)
+            raise "Unable to retrieve transaction to refund for operation=refund, kb_payment_id=#{kb_payment_id}, kb_payment_transaction_id=#{kb_payment_transaction_id}, kb_payment_method_id=#{kb_payment_method_id}" if transaction.nil?
+            transaction
+          end
+
+          dispatch_to_gateways(:refund, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc, linked_transaction_proc)
         end
 
         def get_payment_info(kb_account_id, kb_payment_id, properties, context)
@@ -134,9 +155,10 @@ module Killbill
           payment_source        = get_payment_source(nil, all_properties, options, context)
 
           # Go to the gateway
-          gateway               = lookup_gateway(options[:payment_processor_account_id] || :default)
-          gw_response           = gateway.store(payment_source, options)
-          response, transaction = save_response_and_transaction gw_response, :add_payment_method, kb_account_id, context.tenant_id
+          payment_processor_account_id = options[:payment_processor_account_id] || :default
+          gateway                      = lookup_gateway(payment_processor_account_id)
+          gw_response                  = gateway.store(payment_source, options)
+          response, transaction        = save_response_and_transaction(gw_response, :add_payment_method, kb_account_id, context.tenant_id, payment_processor_account_id)
 
           if response.success
             # If we have skipped the call to the gateway, we still need to store the payment method
@@ -161,13 +183,14 @@ module Killbill
           pm      = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
           # Delete the card
-          gateway = lookup_gateway(options[:payment_processor_account_id] || :default)
+          payment_processor_account_id = options[:payment_processor_account_id] || :default
+          gateway                      = lookup_gateway(payment_processor_account_id)
           if options[:customer_id]
             gw_response = gateway.unstore(options[:customer_id], pm.token, options)
           else
             gw_response = gateway.unstore(pm.token, options)
           end
-          response, transaction = save_response_and_transaction gw_response, :delete_payment_method, kb_account_id, context.tenant_id
+          response, transaction = save_response_and_transaction(gw_response, :delete_payment_method, kb_account_id, context.tenant_id, payment_processor_account_id)
 
           if response.success
             @payment_method_model.mark_as_deleted! kb_payment_method_id, context.tenant_id
@@ -329,7 +352,7 @@ module Killbill
         # TODO Split settlements is partially implemented. Left to be done:
         # * payment_source should probably be retrieved per gateway
         # * amount per gateway should be retrieved from the options
-        def dispatch_to_gateways(operation, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
+        def dispatch_to_gateways(operation, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc, linked_transaction_proc=nil)
           kb_transaction        = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
           amount_in_cents       = amount.nil? ? nil : to_cents(amount, currency)
 
@@ -350,6 +373,13 @@ module Killbill
           # Retrieve the previous transaction for the same operation and payment id - this is useful to detect dups for example
           last_transaction = @transaction_model.send("#{operation.to_s}s_from_kb_payment_id", kb_payment_id, context.tenant_id).last
 
+          # Retrieve the linked transaction (authorization to capture, purchase to refund, etc.)
+          linked_transaction = nil
+          unless linked_transaction_proc.nil?
+            linked_transaction                     = linked_transaction_proc.call(amount_in_cents, options)
+            options[:payment_processor_account_id] ||= linked_transaction.payment_processor_account_id
+          end
+
           # Filter before all gateways call
           before_gateways(kb_transaction, last_transaction, payment_source, amount_in_cents, currency, options)
 
@@ -366,8 +396,8 @@ module Killbill
             before_gateway(gateway, kb_transaction, last_transaction, payment_source, amount_in_cents, currency, options)
 
             # Perform the operation in the gateway
-            gw_response           = gateway_call_proc.call(gateway, payment_source, amount_in_cents, options)
-            response, transaction = save_response_and_transaction(gw_response, operation, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, operation.upcase, amount_in_cents, currency)
+            gw_response           = gateway_call_proc.call(gateway, linked_transaction, payment_source, amount_in_cents, options)
+            response, transaction = save_response_and_transaction(gw_response, operation, kb_account_id, context.tenant_id, payment_processor_account_id, kb_payment_id, kb_payment_transaction_id, operation.upcase, amount_in_cents, currency)
 
             # Filter after each gateway call
             after_gateway(response, transaction, gw_response)
@@ -460,10 +490,10 @@ module Killbill
           account.currency
         end
 
-        def save_response_and_transaction(gw_response, api_call, kb_account_id, kb_tenant_id, kb_payment_id=nil, kb_payment_transaction_id=nil, transaction_type=nil, amount_in_cents=0, currency=nil)
+        def save_response_and_transaction(gw_response, api_call, kb_account_id, kb_tenant_id, payment_processor_account_id, kb_payment_id=nil, kb_payment_transaction_id=nil, transaction_type=nil, amount_in_cents=0, currency=nil)
           @logger.warn "Unsuccessful #{api_call}: #{gw_response.message}" unless gw_response.success?
 
-          response, transaction = @response_model.create_response_and_transaction(@identifier, @transaction_model, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, kb_tenant_id, gw_response, amount_in_cents, currency, {}, @response_model)
+          response, transaction = @response_model.create_response_and_transaction(@identifier, @transaction_model, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, gw_response, amount_in_cents, currency, {}, @response_model)
 
           @logger.debug "Recorded transaction: #{transaction.inspect}" unless transaction.nil?
 
@@ -506,7 +536,7 @@ module Killbill
         end
 
         def get_active_merchant_module
-          ::ActiveMerchant::Billing::Integrations.const_get(@identifier.to_s.camelize)
+          ::OffsitePayments.integration(@identifier.to_s.camelize)
         end
 
         def merge_transaction_info_plugins(payment_processor_account_ids, responses, transactions)