killbill-paypal-express 1.7.0 → 1.7.1

data/killbill-paypal-express.gemspec

@@ -3,7 +3,7 @@ version = File.read(File.expand_path('../VERSION', __FILE__)).strip
 Gem::Specification.new do |s|
   s.name        = 'killbill-paypal-express'
   s.version     = version
-  s.summary     = 'Plugin to use Express Checkout as a gateway.'
+  s.summary     = 'Plugin to use Paypal Express Checkout as a gateway.'
   s.description = 'Kill Bill payment plugin for Paypal Express Checkout.'
 
   s.required_ruby_version = '>= 1.9.3'
@@ -18,17 +18,22 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.bindir        = 'bin'
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 
   s.rdoc_options << '--exclude' << '.'
 
-  s.add_dependency 'killbill', '~> 3.0.0'
-  s.add_dependency 'activemerchant', '~> 1.36.0'
-  s.add_dependency 'activerecord', '~> 3.2.1'
-  s.add_dependency 'money', '~> 6.0.0'
+  s.add_dependency 'killbill', '~> 3.1.8'
+  s.add_dependency 'activemerchant', '~> 1.44.1'
+  s.add_dependency 'offsite_payments', '~> 2.0.1'
+  s.add_dependency 'activerecord', '~> 4.1.0'
+  s.add_dependency 'actionpack', '~> 4.1.0'
+  s.add_dependency 'actionview', '~> 4.1.0'
+  s.add_dependency 'activesupport', '~> 4.1.0'
+  s.add_dependency 'money', '~> 6.1.1'
+  s.add_dependency 'monetize', '~> 0.3.0'
   s.add_dependency 'sinatra', '~> 1.3.4'
   if defined?(JRUBY_VERSION)
-    s.add_dependency 'activerecord-jdbcmysql-adapter', '~> 1.2.9'
+    s.add_dependency 'activerecord-jdbcmysql-adapter', '~> 1.3.7'
     # Required to avoid errors like java.lang.NoClassDefFoundError: org/bouncycastle/asn1/DERBoolean
     s.add_dependency 'jruby-openssl', '~> 0.9.4'
   end
@@ -37,7 +42,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake', '>= 10.0.0'
   s.add_development_dependency 'rspec', '~> 2.12.0'
   if defined?(JRUBY_VERSION)
-    s.add_development_dependency 'activerecord-jdbcsqlite3-adapter', '~> 1.2.6'
+    s.add_development_dependency 'activerecord-jdbcsqlite3-adapter', '~> 1.3.7'
   else
     s.add_development_dependency 'sqlite3', '~> 1.3.7'
   end

data/lib/paypal_express.rb

@@ -1,156 +1,24 @@
+require 'action_controller'
 require 'active_record'
-require 'activemerchant'
+require 'action_view'
+require 'active_merchant'
+require 'active_support'
 require 'bigdecimal'
 require 'money'
+require 'monetize'
+require 'offsite_payments'
 require 'pathname'
 require 'sinatra'
 require 'singleton'
 require 'yaml'
 
 require 'killbill'
-
-require 'paypal_express/config/configuration'
-require 'paypal_express/config/properties'
-
-require 'paypal_express/paypal/gateway'
-
-require 'paypal_express/models/paypal_express_payment_method'
-require 'paypal_express/models/paypal_express_response'
-require 'paypal_express/models/paypal_express_transaction'
-
-require 'paypal_express/paypal_express_utils'
+require 'killbill/helpers/active_merchant'
 
 require 'paypal_express/api'
 require 'paypal_express/private_api'
 
+require 'paypal_express/models/payment_method'
+require 'paypal_express/models/response'
+require 'paypal_express/models/transaction'
 
-# Thank you Rails for the following!
-
-class Object
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-end
-
-class Hash
-  # Return a new hash with all keys converted to symbols, as long as
-  # they respond to +to_sym+. This includes the keys from the root hash
-  # and from all nested hashes.
-  #
-  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
-  #
-  #   hash.deep_symbolize_keys
-  #   # => { person: { name: "Rob", age: "28" } }
-  def deep_symbolize_keys
-    deep_transform_keys { |key| key.to_sym rescue key }
-  end
-
-  # Return a new hash with all keys converted by the block operation.
-  # This includes the keys from the root hash and from all
-  # nested hashes.
-  #
-  #  hash = { person: { name: 'Rob', age: '28' } }
-  #
-  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
-  #  # => { "PERSON" => { "NAME" => "Rob", "AGE" => "28" } }
-  def deep_transform_keys(&block)
-    result = {}
-    each do |key, value|
-      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
-    end
-    result
-  end
-
-  # By default, only instances of Hash itself are extractable.
-  # Subclasses of Hash may implement this method and return
-  # true to declare themselves as extractable. If a Hash
-  # is extractable, Array#extract_options! pops it from
-  # the Array when it is the last element of the Array.
-  def extractable_options?
-    instance_of?(Hash)
-  end
-end
-
-class Array
-  # Extracts options from a set of arguments. Removes and returns the last
-  # element in the array if it's a hash, otherwise returns a blank hash.
-  #
-  #   def options(*args)
-  #     args.extract_options!
-  #   end
-  #
-  #   options(1, 2)        # => {}
-  #   options(1, 2, a: :b) # => {:a=>:b}
-  def extract_options!
-    if last.is_a?(Hash) && last.extractable_options?
-      pop
-    else
-      {}
-    end
-  end
-end
-
-class Module
-  def mattr_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        @@#{sym} = nil unless defined? @@#{sym}
-
-        def self.#{sym}
-          @@#{sym}
-        end
-      EOS
-
-      unless options[:instance_reader] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
-      end
-    end
-  end
-
-  def mattr_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
-
-      unless options[:instance_writer] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
-      end
-    end
-  end
-
-  # Extends the module object with module and instance accessors for class attributes,
-  # just like the native attr* accessors for instance attributes.
-  #
-  #   module AppConfiguration
-  #     mattr_accessor :google_api_key
-  #
-  #     self.google_api_key = "123456789"
-  #   end
-  #
-  #   AppConfiguration.google_api_key # => "123456789"
-  #   AppConfiguration.google_api_key = "overriding the api key!"
-  #   AppConfiguration.google_api_key # => "overriding the api key!"
-  #
-  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
-  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
-  def mattr_accessor(*syms)
-    mattr_reader(*syms)
-    mattr_writer(*syms)
-  end
-end

data/lib/paypal_express/api.rb

@@ -1,235 +1,232 @@
-module Killbill::PaypalExpress
-  class PaymentPlugin < Killbill::Plugin::Payment
-    def start_plugin
-      Killbill::PaypalExpress.initialize! @logger, @conf_dir
-      @gateway = Killbill::PaypalExpress.gateway
+module Killbill #:nodoc:
+  module PaypalExpress #:nodoc:
+    class PaymentPlugin < ::Killbill::Plugin::ActiveMerchant::PaymentPlugin
+
+      def initialize
+        gateway_builder = Proc.new do |config|
+          ::ActiveMerchant::Billing::PaypalExpressGateway.new :signature => config[:signature],
+                                                              :login     => config[:login],
+                                                              :password  => config[:password]
+        end
 
-      @ip = Utils.ip
+        super(gateway_builder,
+              :paypal_express,
+              ::Killbill::PaypalExpress::PaypalExpressPaymentMethod,
+              ::Killbill::PaypalExpress::PaypalExpressTransaction,
+              ::Killbill::PaypalExpress::PaypalExpressResponse)
 
-      super
+        @ip = ::Killbill::Plugin::ActiveMerchant::Utils.ip
+      end
 
-      @logger.info "Killbill::PaypalExpress::PaymentPlugin started"
-    end
+      def authorize_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    # return DB connections to the Pool if required
-    def after_request
-      ActiveRecord::Base.connection.close
-    end
+        add_required_options(kb_payment_transaction_id, kb_payment_method_id, context, options)
 
-    def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount, currency, call_context = nil, options = {})
-      # 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 = Money.new_with_amount(amount, currency).cents.to_i
+        properties        = merge_properties(properties, options)
 
-      # If the payment was already made, just return the status
-      paypal_express_transaction = PaypalExpressTransaction.from_kb_payment_id(kb_payment_id) rescue nil
-      return paypal_express_transaction.paypal_express_response.to_payment_response unless paypal_express_transaction.nil?
+        # Can't use default implementation: the authorize signature is for one-off payments only
+        #super(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, linked_transaction, payment_source, amount_in_cents, options|
+          gateway.authorize_reference_transaction(amount_in_cents, options)
+        end
 
-      # Check for currency conversion
-      actual_amount, actual_currency = convert_amount_currency_if_required(amount_in_cents, currency, kb_payment_id)
+        dispatch_to_gateways(:authorize, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
+      end
 
-      options[:currency] ||= actual_currency.to_s
-      options[:payment_type] ||= 'Any'
-      options[:invoice_id] ||= kb_payment_id
-      options[:description] ||= Killbill::PaypalExpress.paypal_payment_description || "Kill Bill payment for #{kb_payment_id}"
-      options[:ip] ||= @ip
+      def capture_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {
+            # NotComplete to allow for partial captures.
+            # If Complete, any remaining amount of the original authorized transaction is automatically voided and all remaining open authorizations are voided.
+            :complete_type => 'NotComplete'
+        }
 
-      if options[:reference_id].blank?
-        payment_method = PaypalExpressPaymentMethod.from_kb_payment_method_id(kb_payment_method_id)
-        options[:reference_id] = payment_method.paypal_express_baid
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
       end
 
+      def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-      # Go to Paypal (DoReferenceTransaction call)
-      paypal_response = @gateway.reference_transaction actual_amount, options
-      response = save_response_and_transaction paypal_response, :charge, kb_payment_id, actual_amount, actual_currency
-
-      response.to_payment_response
-    end
+        add_required_options(kb_payment_transaction_id, kb_payment_method_id, context, options)
 
-    def get_payment_info(kb_account_id, kb_payment_id, tenant_context = nil, options = {})
-      paypal_express_transaction = PaypalExpressTransaction.from_kb_payment_id(kb_payment_id)
+        properties        = merge_properties(properties, options)
 
-      # We could also re-fetch it via: @gateway.transaction_details(transaction_id)
-      # but we would need to reconstruct the payment_info object
-      paypal_express_transaction.paypal_express_response.to_payment_response
-    end
+        # Can't use default implementation: the purchase signature is for one-off payments only
+        #super(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, linked_transaction, payment_source, amount_in_cents, options|
+          gateway.reference_transaction(amount_in_cents, options)
+        end
 
-    def process_refund(kb_account_id, kb_payment_id, amount, currency, call_context = nil, options = {})
-      # 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 = Money.new_with_amount(amount, currency).cents.to_i
+        dispatch_to_gateways(:purchase, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
+      end
 
-      # Check for currency conversion
-      actual_amount, actual_currency = convert_amount_currency_if_required(amount_in_cents, currency, kb_payment_id)
+      def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {
+            # Void the original authorization
+            :linked_transaction_type => :authorize
+        }
 
-      paypal_express_transaction = PaypalExpressTransaction.find_candidate_transaction_for_refund(kb_payment_id, actual_amount)
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
+      end
 
-      options[:currency] ||= actual_currency.to_s
-      options[:refund_type] ||= paypal_express_transaction.amount_in_cents != actual_amount ? 'Partial' : 'Full'
+      def credit_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-      identification = paypal_express_transaction.paypal_express_txn_id
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
 
-      # Go to Paypal
-      paypal_response = @gateway.refund actual_amount, identification, options
-      response = save_response_and_transaction paypal_response, :refund, kb_payment_id, actual_amount, actual_currency
+      def refund_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Cannot refund based on authorizations (default behavior)
+        linked_transaction_type = @transaction_model.purchases_from_kb_payment_id(kb_payment_id, context.tenant_id).size > 0 ? :purchase : :capture
 
-      response.to_refund_response
-    end
+        # Pass extra parameters for the gateway here
+        options                 = {
+            :linked_transaction_type => linked_transaction_type
+        }
 
-    def get_refund_info(kb_account_id, kb_payment_id, tenant_context = nil, options = {})
-      paypal_express_transactions = PaypalExpressTransaction.refunds_from_kb_payment_id(kb_payment_id)
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
 
-      # We could also re-fetch it via: @gateway.transaction_details(transaction_id)
-      # but we would need to reconstruct the refund_info object
-      paypal_express_transactions.map { |t| t.paypal_express_response.to_refund_response }
-    end
+      def get_payment_info(kb_account_id, kb_payment_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default = false, call_context = nil, options = {})
-      token = (payment_method_props.properties.find { |kv| kv.key == 'token' }).value
-      return false if token.nil?
-
-      # The payment method should have been created during the setup step (see private api)
-      payment_method = PaypalExpressPaymentMethod.from_kb_account_id_and_token(kb_account_id, token)
-
-      # Go to Paypal to get the Payer id (GetExpressCheckoutDetails call)
-      paypal_express_details_response = @gateway.details_for token
-      response = save_response_and_transaction paypal_express_details_response, :details_for
-      return false unless response.success?
-
-      payer_id = response.payer_id
-      unless payer_id.nil?
-        # Go to Paypal to create the BAID for recurring payments (CreateBillingAgreement call)
-        paypal_express_baid_response = @gateway.store token
-        response = save_response_and_transaction paypal_express_baid_response, :create_billing_agreement
-        return false unless response.success?
-
-        if response.billing_agreement_id.blank?
-          # If the baid isn't specified (invalid token, maybe expired?), we won't be able to charge that payment method
-          # See https://github.com/killbill/killbill-paypal-express-plugin/issues/1
-          logger.warn "No BAID returned by the CreateBillingAgreement call for token #{token} (account #{kb_account_id})"
-          return false
-        end
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, properties, context)
+      end
 
-        payment_method.kb_payment_method_id = kb_payment_method_id
-        payment_method.paypal_express_payer_id = payer_id
-        payment_method.paypal_express_baid = response.billing_agreement_id
-        payment_method.save!
+      def search_payments(search_key, offset, limit, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-        logger.info "Created BAID #{payment_method.paypal_express_baid} for payment method #{kb_payment_method_id} (account #{kb_account_id})"
-        true
-      else
-        logger.warn "Unable to retrieve Payer id details for token #{token} (account #{kb_account_id})"
-        false
+        properties = merge_properties(properties, options)
+        super(search_key, offset, limit, properties, context)
       end
-    end
 
-    def delete_payment_method(kb_account_id, kb_payment_method_id, call_context = nil, options = {})
-      PaypalExpressPaymentMethod.mark_as_deleted! kb_payment_method_id
-    end
+      def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
+        token = find_value_from_properties(properties, 'token')
+        return false if token.nil?
+
+        # Go to Paypal to get the Payer id (GetExpressCheckoutDetails call)
+        options                      = properties_to_hash(properties)
+        payment_processor_account_id = options[:payment_processor_account_id] || :default
+        gateway                      = lookup_gateway(payment_processor_account_id)
+        gw_response                  = gateway.details_for(token)
+        response, transaction        = save_response_and_transaction(gw_response, :details_for, kb_account_id, context.tenant_id, payment_processor_account_id)
+        return false unless response.success? and !response.payer_id.blank?
+
+        # Pass extra parameters for the gateway here
+        options = {
+            :paypal_express_token    => token,
+            :paypal_express_payer_id => response.payer_id
+        }
+
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
+      end
 
-    def get_payment_method_detail(kb_account_id, kb_payment_method_id, tenant_context = nil, options = {})
-      PaypalExpressPaymentMethod.from_kb_payment_method_id(kb_payment_method_id).to_payment_method_response
-    end
+      def delete_payment_method(kb_account_id, kb_payment_method_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def set_default_payment_method(kb_account_id, kb_payment_method_id, call_context = nil, options = {})
-      # No-op
-    end
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, properties, context)
+      end
 
-    def get_payment_methods(kb_account_id, refresh_from_gateway, call_context = nil, options = {})
-      PaypalExpressPaymentMethod.from_kb_account_id(kb_account_id).collect { |pm| pm.to_payment_method_info_response }
-    end
+      def get_payment_method_detail(kb_account_id, kb_payment_method_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def reset_payment_methods(kb_account_id, payment_methods)
-      return if payment_methods.nil?
-
-      paypal_pms = PaypalExpressPaymentMethod.from_kb_account_id(kb_account_id)
-
-      payment_methods.delete_if do |payment_method_info_plugin|
-        should_be_deleted = false
-        paypal_pms.each do |paypal_pm|
-          # Do paypal_pm and payment_method_info_plugin represent the same PayPal payment method?
-          if paypal_pm.external_payment_method_id == payment_method_info_plugin.external_payment_method_id
-            # Do we already have a kb_payment_method_id?
-            if paypal_pm.kb_payment_method_id == payment_method_info_plugin.payment_method_id
-              should_be_deleted = true
-              break
-            elsif paypal_pm.kb_payment_method_id.nil?
-              # We didn't have the kb_payment_method_id - update it
-              paypal_pm.kb_payment_method_id = payment_method_info_plugin.payment_method_id
-              should_be_deleted = paypal_pm.save
-              break
-              # Otherwise the same BAID points to 2 different kb_payment_method_id. This should never happen,
-              # but we cowardly will insert a second row below
-            end
-          end
-        end
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, properties, context)
+      end
 
-        should_be_deleted
+      def set_default_payment_method(kb_account_id, kb_payment_method_id, properties, context)
+        # TODO
       end
 
-      # The remaining elements in payment_methods are not in our table (this should never happen?!)
-      payment_methods.each do |payment_method_info_plugin|
-        PaypalExpressPaymentMethod.create :kb_account_id => payment_method_info_plugin.account_id,
-                                          :kb_payment_method_id => payment_method_info_plugin.payment_method_id,
-                                          :paypal_express_baid => payment_method_info_plugin.external_payment_method_id,
-                                          :paypal_express_token => 'unknown (created by reset)'
+      def get_payment_methods(kb_account_id, refresh_from_gateway, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+
+        properties = merge_properties(properties, options)
+        super(kb_account_id, refresh_from_gateway, properties, context)
       end
-    end
 
-    def search_payments(search_key, offset = 0, limit = 100, call_context = nil, options = {})
-      PaypalExpressResponse.search(search_key, offset, limit, :payment)
-    end
+      def search_payment_methods(search_key, offset, limit, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
 
-    def search_refunds(search_key, offset = 0, limit = 100, call_context = nil, options = {})
-      PaypalExpressResponse.search(search_key, offset, limit, :refund)
-    end
+        properties = merge_properties(properties, options)
+        super(search_key, offset, limit, properties, context)
+      end
 
-    def search_payment_methods(search_key, offset = 0, limit = 100, call_context = nil, options = {})
-      PaypalExpressPaymentMethod.search(search_key, offset, limit)
-    end
+      def reset_payment_methods(kb_account_id, payment_methods, properties, context)
+        super
+      end
 
-    private
+      def build_form_descriptor(kb_account_id, descriptor_fields, properties, context)
+        # Pass extra parameters for the gateway here
+        options           = {}
+        properties        = merge_properties(properties, options)
 
-    def convert_amount_currency_if_required(input_amount, input_currency, kb_payment_id)
+        # Add your custom static hidden tags here
+        options           = {
+            #:token => config[:paypal-express][:token]
+        }
+        descriptor_fields = merge_properties(descriptor_fields, options)
 
-      converted_currency = Killbill::PaypalExpress.converted_currency(input_currency)
-      return [input_amount, input_currency] if converted_currency.nil?
+        super(kb_account_id, descriptor_fields, properties, context)
+      end
 
-      kb_payment = @kb_apis.payment_api.get_payment(kb_payment_id, false, @kb_apis.create_context)
+      def process_notification(notification, properties, context)
+        # Pass extra parameters for the gateway here
+        options    = {}
+        properties = merge_properties(properties, options)
+
+        super(notification, properties, context) do |gw_notification, service|
+          # Retrieve the payment
+          # gw_notification.kb_payment_id =
+          #
+          # Set the response body
+          # gw_notification.entity =
+        end
+      end
 
-      currency_conversion = @kb_apis.currency_conversion_api.get_currency_conversion(converted_currency, kb_payment.effective_date)
-      rates = currency_conversion.rates
-      found = rates.select do |r|
-        r.currency.to_s.upcase.to_sym == input_currency.to_s.upcase.to_sym
+      def to_express_checkout_url(response, options = {})
+        payment_processor_account_id = options[:payment_processor_account_id] || :default
+        gateway                      = lookup_gateway(payment_processor_account_id)
+        gateway.redirect_url_for(response.token)
       end
 
-      if found.nil? || found.empty?
-        @logger.warn "Failed to find converted currency #{converted_currency} for input currency #{input_currency}"
-        return [input_amount, input_currency]
+      protected
+
+      def get_active_merchant_module
+        ::OffsitePayments.integration(:paypal)
       end
 
-      # conversion rounding ?
-      conversion_rate = found[0].value
-      output_amount =  input_amount * conversion_rate
-      return [output_amount.to_i, converted_currency]
-    end
+      private
 
-    def save_response_and_transaction(paypal_express_response, api_call, kb_payment_id=nil, amount_in_cents=0, currency=nil)
-      @logger.warn "Unsuccessful #{api_call}: #{paypal_express_response.message}" unless paypal_express_response.success?
+      def add_required_options(kb_payment_transaction_id, kb_payment_method_id, context, options)
+        payment_method = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
-      # Save the response to our logs
-      response = PaypalExpressResponse.from_response(api_call, kb_payment_id, paypal_express_response)
-      response.save!
+        options[:payer_id]     ||= payment_method.paypal_express_payer_id
+        options[:token]        ||= payment_method.paypal_express_token
+        options[:reference_id] ||= payment_method.token # baid
 
-      if response.success and !kb_payment_id.blank? and !response.authorization.blank?
-        # Record the transaction
-        transaction = response.create_paypal_express_transaction!(:amount_in_cents => amount_in_cents,
-                                                                  :currency => currency,
-                                                                  :api_call => api_call,
-                                                                  :kb_payment_id => kb_payment_id,
-                                                                  :paypal_express_txn_id => response.authorization)
-        @logger.debug "Recorded transaction: #{transaction.inspect}"
+        options[:payment_type] ||= 'Any'
+        options[:invoice_id]   ||= kb_payment_transaction_id
+        options[:ip]           ||= @ip
       end
-      response
     end
   end
 end