killbill 3.0.0 → 3.1.0

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

@@ -0,0 +1,35 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      module ActiveRecord
+        require 'active_record'
+
+        # Closest from a streaming API as we can get with ActiveRecord
+        class StreamyResultSet
+          include Enumerable
+
+          def initialize(limit, batch_size = 100, &delegate)
+            @limit = limit
+            @batch = [batch_size, limit].min
+            @delegate = delegate
+          end
+
+          def each(&block)
+            (0..(@limit - @batch)).step(@batch) do |i|
+              result = @delegate.call(i, @batch)
+              block.call(result)
+              # Optimization: bail out if no more results
+              break if result.nil? || result.empty?
+            end if @batch > 0
+            # Make sure to return DB connections to the Pool
+            ::ActiveRecord::Base.connection.close
+          end
+
+          def to_a
+            super.to_a.flatten
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      module ActiveRecord
+        require 'active_record'
+
+        class Transaction < ::ActiveRecord::Base
+
+          self.abstract_class = true
+
+          def self.authorization_from_kb_payment_id(kb_payment_id)
+            transaction_from_kb_payment_id :authorize, kb_payment_id, :single
+          end
+
+          def self.charge_from_kb_payment_id(kb_payment_id)
+            transaction_from_kb_payment_id :charge, kb_payment_id, :single
+          end
+
+          def self.refunds_from_kb_payment_id(kb_payment_id)
+            transaction_from_kb_payment_id :refund, kb_payment_id, :multiple
+          end
+
+          def self.find_candidate_transaction_for_refund(kb_payment_id, amount_in_cents)
+            begin
+              do_find_candidate_transaction_for_refund :authorize, kb_payment_id, amount_in_cents
+            rescue
+              do_find_candidate_transaction_for_refund :charge, kb_payment_id, amount_in_cents
+            end
+          end
+
+          def self.do_find_candidate_transaction_for_refund(api_call, kb_payment_id, amount_in_cents)
+            # Find one successful charge which amount is at least the amount we are trying to refund
+            transactions = where('amount_in_cents >= ? AND api_call = ? and kb_payment_id = ?', amount_in_cents, api_call, kb_payment_id)
+            raise "Unable to find transaction for payment #{kb_payment_id} and api_call #{api_call}" if transactions.size == 0
+
+            # We have candidates, but we now need to make sure we didn't refund more than for the specified amount
+            amount_refunded_in_cents = where('api_call = ? and kb_payment_id = ?', :refund, kb_payment_id)
+                                       .sum('amount_in_cents')
+
+            amount_left_to_refund_in_cents = -amount_refunded_in_cents
+            transactions.map { |transaction| amount_left_to_refund_in_cents += transaction.amount_in_cents }
+            raise "Amount #{amount_in_cents} too large to refund for payment #{kb_payment_id}" if amount_left_to_refund_in_cents < amount_in_cents
+
+            transactions.first
+          end
+
+          private
+
+          def self.transaction_from_kb_payment_id(api_call, kb_payment_id, how_many)
+            transactions = where('api_call = ? and kb_payment_id = ?', api_call, kb_payment_id)
+            raise "Unable to find transaction id for payment #{kb_payment_id}" if transactions.empty?
+            if how_many == :single
+              raise "Kill Bill payment #{kb_payment_id} 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/configuration.rb

@@ -0,0 +1,54 @@
+require 'logger'
+
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      mattr_reader :config
+      mattr_reader :currency_conversions
+      mattr_reader :gateway
+      mattr_reader :initialized
+      mattr_reader :kb_apis
+      mattr_reader :logger
+      mattr_reader :test
+
+      def self.initialize!(gateway_builder, gateway_name, logger, config_file, kb_apis)
+        @@config = Properties.new(config_file)
+        @@config.parse!
+
+        @@currency_conversions = @@config[:currency_conversions]
+        @@kb_apis = kb_apis
+        @@test = @@config[gateway_name][:test]
+
+        @@gateway = Gateway.wrap(gateway_builder, @@config[gateway_name.to_sym])
+
+        @@logger = logger
+        @@logger.log_level = Logger::DEBUG if (@@config[:logger] || {})[:debug]
+
+        if defined?(JRUBY_VERSION)
+          begin
+            # See https://github.com/jruby/activerecord-jdbc-adapter/issues/302
+            require 'jdbc/mysql'
+            ::Jdbc::MySQL.load_driver(:require) if ::Jdbc::MySQL.respond_to?(:load_driver)
+          rescue => e
+            @@logger.warn "Unable to load the JDBC driver: #{e}"
+          end
+        end
+
+        begin
+          require 'active_record'
+          ::ActiveRecord::Base.establish_connection(@@config[:database])
+          ::ActiveRecord::Base.logger = @@logger
+        rescue => e
+          @@logger.warn "Unable to establish a database connection: #{e}"
+        end
+
+        @@initialized = true
+      end
+
+      def self.converted_currency(currency)
+        currency_sym = currency.to_s.upcase.to_sym
+        @@currency_conversions && @@currency_conversions[currency_sym]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# Thank you Rails!
+class String
+  def camelize(uppercase_first_letter = true)
+    string = to_s
+    if uppercase_first_letter
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+    else
+      string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+    end
+    string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+    string.gsub!('/', '::')
+    string
+  end unless respond_to?(:camelize)
+end
+
+class Integer
+  def base(b)
+    self < b ? [self] : (self/b).base(b) + [self%b]
+  end
+end
+
+begin
+  require 'securerandom'
+  SecureRandom.uuid
+rescue LoadError, NoMethodError
+  # See http://jira.codehaus.org/browse/JRUBY-6176
+  module SecureRandom
+    def self.uuid
+      ary = self.random_bytes(16).unpack("NnnnnN")
+      ary[2] = (ary[2] & 0x0fff) | 0x4000
+      ary[3] = (ary[3] & 0x3fff) | 0x8000
+      "%08x-%04x-%04x-%04x-%04x%08x" % ary
+    end unless respond_to?(:uuid)
+  end
+end
+
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end

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

@@ -0,0 +1,35 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      require 'active_merchant'
+
+      class Gateway
+        def self.wrap(gateway_builder, config)
+          if config[:test]
+            ::ActiveMerchant::Billing::Base.mode = :test
+          end
+
+          if config[:log_file]
+            ::ActiveMerchant::Billing::Gateway.wiredump_device = File.open(config[:log_file], 'w')
+            ::ActiveMerchant::Billing::Gateway.wiredump_device.sync = true
+          end
+
+          Gateway.new(gateway_builder.call(config))
+        end
+
+        def initialize(am_gateway)
+          @gateway = am_gateway
+        end
+
+        # Unfortunate name...
+        def capture(money, authorization, options = {})
+          @gateway.capture(money, authorization, options)
+        end
+
+        def method_missing(m, *args, &block)
+          @gateway.send(m, *args, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      module RSpec
+
+        def create_payment_method(payment_method_model=::Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod, kb_account_id=nil)
+          kb_payment_method_id = SecureRandom.uuid
+
+          if kb_account_id.nil?
+            kb_account_id = SecureRandom.uuid
+
+            # Create a new account
+            create_kb_account kb_account_id
+          end
+
+          account = @plugin.kb_apis.account_user_api.get_account_by_id(kb_account_id, @plugin.kb_apis.create_context)
+
+          # Generate a token
+          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
+
+          properties = []
+          properties << create_pm_kv_info('ccNumber', cc_number)
+          properties << create_pm_kv_info('ccFirstName', cc_first_name)
+          properties << create_pm_kv_info('ccLastName', cc_last_name)
+          properties << create_pm_kv_info('ccType', cc_type)
+          properties << create_pm_kv_info('ccExpirationMonth', cc_exp_month)
+          properties << create_pm_kv_info('ccExpirationYear', cc_exp_year)
+          properties << create_pm_kv_info('ccLast4', cc_last_4)
+          properties << create_pm_kv_info('email', account.nil? ? nil : account.email)
+          properties << create_pm_kv_info('address1', address1)
+          properties << create_pm_kv_info('address2', address2)
+          properties << create_pm_kv_info('city', city)
+          properties << create_pm_kv_info('state', state)
+          properties << create_pm_kv_info('zip', zip)
+          properties << create_pm_kv_info('country', country)
+          properties << create_pm_kv_info('ccVerificationValue', cc_verification_value)
+
+          info            = Killbill::Plugin::Model::PaymentMethodPlugin.new
+          info.properties = properties
+          payment_method  = @plugin.add_payment_method(kb_account_id, kb_payment_method_id, info, true, nil)
+
+          pm = payment_method_model.from_kb_payment_method_id kb_payment_method_id
+          pm.should == payment_method
+          pm.kb_account_id.should == kb_account_id
+          pm.kb_payment_method_id.should == kb_payment_method_id
+          # Depends on the gateway
+          #pm.cc_first_name.should == cc_first_name + ' ' + cc_last_name
+          #pm.cc_last_name.should == cc_last_name
+          pm.cc_type.should == cc_type
+          pm.cc_exp_month.should == cc_exp_month
+          pm.cc_exp_year.should == cc_exp_year
+          #pm.cc_last_4.should == cc_last_4
+          pm.address1.should == address1
+          pm.address2.should == address2
+          pm.city.should == city
+          pm.state.should == state
+          pm.zip.should == zip.to_s
+          pm.country.should == country
+
+          pm
+        end
+
+        def create_kb_account(kb_account_id)
+          external_key = Time.now.to_i.to_s + '-test'
+          email        = external_key + '@tester.com'
+
+          account              = ::Killbill::Plugin::Model::Account.new
+          account.id           = kb_account_id
+          account.external_key = external_key
+          account.email        = email
+          account.name         = 'Integration spec'
+          account.currency     = :USD
+
+          @account_api.accounts << account
+
+          return external_key, kb_account_id
+        end
+
+        def create_pm_kv_info(key, value)
+          prop       = ::Killbill::Plugin::Model::PaymentMethodKVInfo.new
+          prop.key   = key
+          prop.value = value
+          prop
+        end
+
+        class FakeJavaUserAccountApi
+          attr_accessor :accounts
+
+          def initialize
+            @accounts = []
+          end
+
+          def get_account_by_id(id, context)
+            @accounts.find { |account| account.id == id.to_s }
+          end
+
+          def get_account_by_key(external_key, context)
+            @accounts.find { |account| account.external_key == external_key.to_s }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,365 @@
+module Killbill
+  module Plugin
+    module ActiveMerchant
+      require 'active_record'
+      require 'money'
+
+      class PaymentPlugin < ::Killbill::Plugin::Payment
+
+        def initialize(gateway_builder, identifier, payment_method_model, transaction_model, response_model)
+          super()
+
+          @gateway_builder      = gateway_builder
+          @identifier           = identifier
+          @payment_method_model = payment_method_model
+          @transaction_model    = transaction_model
+          @response_model       = response_model
+        end
+
+        def start_plugin
+          ::Killbill::Plugin::ActiveMerchant.initialize! @gateway_builder,
+                                                         @identifier.to_sym,
+                                                         @logger,
+                                                         "#{@conf_dir}/#{@identifier.to_s}.yml",
+                                                         @kb_apis
+
+          super
+
+          @logger.info "#{@identifier} payment plugin started"
+        end
+
+        # return DB connections to the Pool if required
+        def after_request
+          ::ActiveRecord::Base.connection.close
+        end
+
+        def authorize_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount, currency, properties, context)
+          options = properties_to_hash(properties)
+
+          # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
+          amount_in_cents = Monetize.from_numeric(amount, currency).cents.to_i
+
+          # If the authorization was already made, just return the status (one auth per kb payment id)
+          transaction = @transaction_model.authorization_from_kb_payment_id(kb_payment_id) rescue nil
+          return transaction.send("#{@identifier}_response").to_payment_response(transaction) unless transaction.nil?
+
+          options[:order_id]    ||= kb_payment_id
+          options[:currency]    ||= currency.to_s.upcase
+          options[:description] ||= "Kill Bill authorization for #{kb_payment_id}"
+
+          # Retrieve the payment method
+          if options[:credit_card].blank?
+            pm             = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id)
+            payment_source = pm.token
+          else
+            payment_source = ::ActiveMerchant::Billing::CreditCard.new(options[:credit_card])
+          end
+
+          # Go to the gateway
+          gw_response           = gateway.authorize amount_in_cents, payment_source, options
+          response, transaction = save_response_and_transaction gw_response, :authorize, kb_payment_id, amount_in_cents, currency
+
+          response.to_payment_response(transaction)
+        end
+
+        def capture_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount, currency, properties, context)
+          options = properties_to_hash(properties)
+
+          # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
+          amount_in_cents = Monetize.from_numeric(amount, currency).cents.to_i
+
+          options[:order_id]    ||= kb_payment_id
+          options[:currency]    ||= currency.to_s.upcase
+          options[:description] ||= "Kill Bill capture for #{kb_payment_id}"
+
+          # Retrieve the authorization
+          authorization = @transaction_model.authorization_from_kb_payment_id(kb_payment_id).txn_id
+
+          # Go to the gateway
+          gw_response           = gateway.capture amount_in_cents, authorization, options
+          response, transaction = save_response_and_transaction gw_response, :capture, kb_payment_id, amount_in_cents, currency
+
+          response.to_payment_response(transaction)
+        end
+
+        def void_payment(kb_account_id, kb_payment_id, kb_payment_method_id, properties, context)
+          options = properties_to_hash(properties)
+          options[:description] ||= "Kill Bill void for #{kb_payment_id}"
+
+          # Retrieve the authorization
+          authorization = @transaction_model.authorization_from_kb_payment_id(kb_payment_id).txn_id
+
+          # Go to the gateway
+          gw_response           = gateway.void authorization, options
+          response, transaction = save_response_and_transaction gw_response, :void, kb_payment_id
+
+          response.to_payment_response(transaction)
+        end
+
+        def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount, currency, properties, context)
+          options = properties_to_hash(properties)
+
+          # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
+          amount_in_cents = Monetize.from_numeric(amount, currency).cents.to_i
+
+          # If the payment was already made, just return the status
+          transaction = @transaction_model.charge_from_kb_payment_id(kb_payment_id) rescue nil
+          return transaction.send("#{@identifier}_response").to_payment_response(transaction) unless transaction.nil?
+
+          options[:order_id]    ||= kb_payment_id
+          options[:currency]    ||= currency.to_s.upcase
+          options[:description] ||= "Kill Bill payment for #{kb_payment_id}"
+
+          # Retrieve the payment method
+          if options[:credit_card].blank?
+            pm             = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id)
+            payment_source = pm.token
+          else
+            payment_source = ::ActiveMerchant::Billing::CreditCard.new(options[:credit_card])
+          end
+
+          # Go to the gateway
+          gw_response           = gateway.purchase amount_in_cents, payment_source, options
+          response, transaction = save_response_and_transaction gw_response, :charge, kb_payment_id, amount_in_cents, currency
+
+          response.to_payment_response(transaction)
+        end
+
+        def process_refund(kb_account_id, kb_payment_id, amount, currency, properties, context)
+          options = properties_to_hash(properties)
+
+          # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
+          amount_in_cents = Monetize.from_numeric(amount, currency).cents.to_i
+
+          transaction           = @transaction_model.find_candidate_transaction_for_refund(kb_payment_id, amount_in_cents)
+
+          # Go to the gateway
+          gw_response           = gateway.refund amount_in_cents, transaction.txn_id, options
+          response, transaction = save_response_and_transaction gw_response, :refund, kb_payment_id, amount_in_cents, currency
+
+          response.to_refund_response(transaction)
+        end
+
+        def get_payment_info(kb_account_id, kb_payment_id, properties, context)
+          options = properties_to_hash(properties)
+
+          # We assume the payment is immutable in the Gateway and only look at our tables
+          transaction = @transaction_model.charge_from_kb_payment_id(kb_payment_id)
+
+          transaction.send("#{@identifier}_response").to_payment_response(transaction)
+        end
+
+        def get_refund_info(kb_account_id, kb_payment_id, properties, context)
+          options = properties_to_hash(properties)
+
+          # We assume the refund is immutable in the Gateway and only look at our tables
+          transactions = @transaction_model.refunds_from_kb_payment_id(kb_payment_id)
+
+          transactions.map { |t| t.send("#{@identifier}_response").to_refund_response(t) }
+        end
+
+        def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
+          options = properties_to_hash(properties)
+          options[:set_default] ||= set_default
+
+          # Registering a card or a token
+          cc_or_token = find_value_from_payment_method_props(payment_method_props, 'token') || find_value_from_payment_method_props(payment_method_props, 'cardId')
+          if cc_or_token.blank?
+            # Nope - real credit card
+            cc_or_token = ::ActiveMerchant::Billing::CreditCard.new(
+                :number             => find_value_from_payment_method_props(payment_method_props, 'ccNumber'),
+                :brand              => find_value_from_payment_method_props(payment_method_props, 'ccType'),
+                :month              => find_value_from_payment_method_props(payment_method_props, 'ccExpirationMonth'),
+                :year               => find_value_from_payment_method_props(payment_method_props, 'ccExpirationYear'),
+                :verification_value => find_value_from_payment_method_props(payment_method_props, 'ccVerificationValue'),
+                :first_name         => find_value_from_payment_method_props(payment_method_props, 'ccFirstName'),
+                :last_name          => find_value_from_payment_method_props(payment_method_props, 'ccLastName')
+            )
+          end
+
+          options[:billing_address] ||= {
+              :email    => find_value_from_payment_method_props(payment_method_props, 'email'),
+              :address1 => find_value_from_payment_method_props(payment_method_props, 'address1'),
+              :address2 => find_value_from_payment_method_props(payment_method_props, 'address2'),
+              :city     => find_value_from_payment_method_props(payment_method_props, 'city'),
+              :zip      => find_value_from_payment_method_props(payment_method_props, 'zip'),
+              :state    => find_value_from_payment_method_props(payment_method_props, 'state'),
+              :country  => find_value_from_payment_method_props(payment_method_props, 'country')
+          }
+
+          # To make various gateway implementations happy...
+          options[:billing_address].each { |k,v| options[k] ||= v }
+
+          options[:order_id]    ||= kb_payment_method_id
+
+          # Go to the gateway
+          gw_response           = gateway.store cc_or_token, options
+          response, transaction = save_response_and_transaction gw_response, :add_payment_method
+
+          if response.success
+            payment_method = @payment_method_model.from_response(kb_account_id, kb_payment_method_id, cc_or_token, gw_response, options)
+            payment_method.save!
+            payment_method
+          else
+            raise response.message
+          end
+        end
+
+        def delete_payment_method(kb_account_id, kb_payment_method_id, properties, context)
+          options = properties_to_hash(properties)
+
+          pm = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id)
+
+          # Delete the card
+          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
+
+          if response.success
+            @payment_method_model.mark_as_deleted! kb_payment_method_id
+          else
+            raise response.message
+          end
+        end
+
+        def get_payment_method_detail(kb_account_id, kb_payment_method_id, properties, context)
+          options = properties_to_hash(properties)
+          @payment_method_model.from_kb_payment_method_id(kb_payment_method_id).to_payment_method_response
+        end
+
+        def get_payment_methods(kb_account_id, refresh_from_gateway = false, properties, context)
+          options = properties_to_hash(properties)
+          @payment_method_model.from_kb_account_id(kb_account_id).collect { |pm| pm.to_payment_method_info_response }
+        end
+
+        def reset_payment_methods(kb_account_id, payment_methods, properties)
+          return if payment_methods.nil?
+
+          options = properties_to_hash(properties)
+
+          pms = @payment_method_model.from_kb_account_id(kb_account_id)
+
+          payment_methods.delete_if do |payment_method_info_plugin|
+            should_be_deleted = false
+            pms.each do |pm|
+              # Do pm and payment_method_info_plugin represent the same payment method?
+              if pm.external_payment_method_id == payment_method_info_plugin.external_payment_method_id
+                # Do we already have a kb_payment_method_id?
+                if pm.kb_payment_method_id == payment_method_info_plugin.payment_method_id
+                  should_be_deleted = true
+                  break
+                elsif pm.kb_payment_method_id.nil?
+                  # We didn't have the kb_payment_method_id - update it
+                  pm.kb_payment_method_id = payment_method_info_plugin.payment_method_id
+                  should_be_deleted       = pm.save
+                  break
+                  # Otherwise the same token points to 2 different kb_payment_method_id. This should never happen!
+                end
+              end
+            end
+
+            should_be_deleted
+          end
+
+          # The remaining elements in payment_methods are not in our table (this should never happen?!)
+          payment_methods.each do |payment_method_info_plugin|
+            pm = @payment_method_model.create :kb_account_id        => kb_account_id,
+                                              :kb_payment_method_id => payment_method_info_plugin.payment_method_id,
+                                              :token                => payment_method_info_plugin.external_payment_method_id
+          end
+        end
+
+        def search_payments(search_key, offset = 0, limit = 100, properties, context)
+          options = properties_to_hash(properties)
+          @response_model.search(search_key, offset, limit, :payment)
+        end
+
+        def search_refunds(search_key, offset = 0, limit = 100, properties, context)
+          options = properties_to_hash(properties)
+          @response_model.search(search_key, offset, limit, :refund)
+        end
+
+        def search_payment_methods(search_key, offset = 0, limit = 100, properties, context)
+          options = properties_to_hash(properties)
+          @payment_method_model.search(search_key, offset, limit)
+        end
+
+        def build_form_descriptor(kb_account_id, descriptor_fields, properties, context)
+          options = properties_to_hash(properties)
+        end
+
+        def process_notification(notification, properties, context)
+          options = properties_to_hash(properties)
+        end
+
+        # Utilities
+
+        # Deprecated
+        def find_value_from_payment_method_props(payment_method_props, key)
+          find_value_from_properties(payment_method_props, key)
+        end
+
+        def find_value_from_properties(properties, key)
+          prop = (payment_method_props.properties.find { |kv| kv.key == key })
+          prop.nil? ? nil : prop.value
+        end
+
+        def account_currency(kb_account_id)
+          account = @kb_apis.account_user_api.get_account_by_id(kb_account_id, @kb_apis.create_context)
+          account.currency
+        end
+
+        def save_response_and_transaction(response, api_call, kb_payment_id=nil, amount_in_cents=0, currency=nil)
+          @logger.warn "Unsuccessful #{api_call}: #{response.message}" unless response.success?
+
+          # Save the response to our logs
+          response = @response_model.from_response(api_call, kb_payment_id, response)
+          response.save!
+
+          transaction = nil
+          txn_id      = response.txn_id
+          if response.success and !kb_payment_id.blank? and !txn_id.blank?
+            # Record the transaction
+            transaction = response.send("create_#{@identifier}_transaction!",
+                                        :amount_in_cents => amount_in_cents,
+                                        :currency        => currency,
+                                        :api_call        => api_call,
+                                        :kb_payment_id   => kb_payment_id,
+                                        :txn_id          => txn_id)
+
+            @logger.debug "Recorded transaction: #{transaction.inspect}"
+          end
+          return response, transaction
+        end
+
+        def gateway
+          ::Killbill::Plugin::ActiveMerchant.gateway
+        end
+
+        def properties_to_hash(properties, options = {})
+          merged = {}
+          properties.each do |p|
+            merged[p.key.to_sym] = p.value
+          end
+          merged.merge(options)
+        end
+
+        def merge_properties(properties, options)
+          merged = properties_to_hash(properties, options)
+
+          properties = []
+          merged.each do |k, v|
+            p       = ::Killbill::Plugin::Model::PluginProperty.new
+            p.key   = k
+            p.value = v
+            properties << p
+          end
+          properties
+        end
+      end
+    end
+  end
+end