killbill 3.2.4 → 4.0.0

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

@@ -4,30 +4,7 @@ module Killbill
       require 'active_merchant'
 
       class Gateway
-        def self.wrap(gateway_builder, logger, config)
-          ::ActiveMerchant::Billing::Gateway.logger = logger
-
-          if config[:test]
-            ::ActiveMerchant::Billing::Base.mode = :test
-          end
-
-          if config[:log_file]
-            ::ActiveMerchant::Billing::Gateway.wiredump_device = File.open(config[:log_file], 'w')
-          else
-            log_method = config[:quiet] ? :debug : :info
-            ::ActiveMerchant::Billing::Gateway.wiredump_device = ::Killbill::Plugin::ActiveMerchant::Utils::KBWiredumpDevice.new(logger, log_method)
-          end
-          ::ActiveMerchant::Billing::Gateway.wiredump_device.sync = true
-
-          ::ActiveMerchant::Billing::Gateway.open_timeout  = config[:open_timeout] unless config[:open_timeout].nil?
-          ::ActiveMerchant::Billing::Gateway.read_timeout  = config[:read_timeout] unless config[:read_timeout].nil?
-          ::ActiveMerchant::Billing::Gateway.retry_safe    = config[:retry_safe] unless config[:retry_safe].nil?
-          ::ActiveMerchant::Billing::Gateway.ssl_strict    = config[:ssl_strict] unless config[:ssl_strict].nil?
-          ::ActiveMerchant::Billing::Gateway.ssl_version   = config[:ssl_version] unless config[:ssl_version].nil?
-          ::ActiveMerchant::Billing::Gateway.max_retries   = config[:max_retries] unless config[:max_retries].nil?
-          ::ActiveMerchant::Billing::Gateway.proxy_address = config[:proxy_address] unless config[:proxy_address].nil?
-          ::ActiveMerchant::Billing::Gateway.proxy_port    = config[:proxy_port] unless config[:proxy_port].nil?
-
+        def self.wrap(gateway_builder, config)
           Gateway.new(config, gateway_builder.call(config))
         end
 
@@ -36,17 +13,53 @@ module Killbill
         def initialize(config, am_gateway)
           @config = config
           @gateway = am_gateway
+
+          # Override urls if needed (there is no easy way to do it earlier, because AM uses class_attribute)
+          @gateway.class.test_url = @config[:test_url] unless @config[:test_url].nil?
+          @gateway.class.live_url = @config[:live_url] unless @config[:live_url].nil?
+        end
+
+        #
+        # Materialize the most common operations - this is for performance reasons
+        #
+
+        def store(*args, &block)
+          method_missing(:store, *args, &block)
+        end
+
+        def unstore(*args, &block)
+          method_missing(:unstore, *args, &block)
+        end
+
+        def authorize(*args, &block)
+          method_missing(:authorize, *args, &block)
         end
 
         # Unfortunate name...
-        def capture(money, authorization, options = {})
-          method_missing(:capture, money, authorization, options)
+        def capture(*args, &block)
+          method_missing(:capture, *args, &block)
+        end
+
+        def purchase(*args, &block)
+          method_missing(:purchase, *args, &block)
+        end
+
+        def void(*args, &block)
+          method_missing(:void, *args, &block)
+        end
+
+        def credit(*args, &block)
+          method_missing(:credit, *args, &block)
+        end
+
+        def refund(*args, &block)
+          method_missing(:refund, *args, &block)
         end
 
         def method_missing(m, *args, &block)
           # The options hash should be the last argument, iterate through all to be safe
           args.reverse.each do |arg|
-            if arg.respond_to?(:has_key?) && arg.has_key?(:skip_gw)
+            if arg.respond_to?(:has_key?) && Utils.normalized(arg, :skip_gw)
               return ::ActiveMerchant::Billing::Response.new(true, 'Skipped Gateway call')
             end
           end

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

@@ -2,29 +2,30 @@ module Killbill
   module Plugin
     module ActiveMerchant
       module RSpec
+        include ::Killbill::Plugin::PropertiesHelper
 
-        def create_payment_method(payment_method_model=::Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod, kb_account_id=nil, kb_tenant_id=nil, properties = [], options = {})
+        def create_payment_method(payment_method_model=::Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod, kb_account_id=nil, kb_tenant_id=nil, properties = [], options = {}, set_default = true, plugin = @plugin)
           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
+            create_kb_account(kb_account_id, plugin.kb_apis.proxied_services[:account_user_api])
           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)
 
           # Generate a token
-          pm_properties = build_pm_properties(account, options)
+          pm_properties = build_pm_properties(account, options, set_default)
 
           info = Killbill::Plugin::Model::PaymentMethodPlugin.new
           info.properties = pm_properties
-          payment_method = @plugin.add_payment_method(kb_account_id, kb_payment_method_id, info, true, properties, context)
+          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.should == payment_method
@@ -34,47 +35,47 @@ module Killbill
           pm
         end
 
-        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)
+        def build_pm_properties(account = nil, overrides = {}, set_defaults = true)
+          cc_number = (overrides.delete(:cc_number) || (set_defaults ? '4242424242424242' : nil))
+          cc_first_name = (overrides.delete(:cc_first_name) || (set_defaults ? 'John' : nil))
+          cc_last_name = (overrides.delete(:cc_last_name) || (set_defaults ? 'Doe' : nil))
+          cc_type = (overrides.delete(:cc_type) || (set_defaults ? 'Visa' : nil))
+          cc_exp_month = (overrides.delete(:cc_exp_month) || (set_defaults ? 12 : nil))
+          cc_exp_year = (overrides.delete(:cc_exp_year) || (set_defaults ? 2017 : nil))
+          cc_last_4 = (overrides.delete(:cc_last_4) || (set_defaults ? 4242 : nil))
+          address1 = (overrides.delete(:address1) || (set_defaults ? '5, oakriu road' : nil))
+          address2 = (overrides.delete(:address2) || (set_defaults ? 'apt. 298' : nil))
+          city = (overrides.delete(:city) || (set_defaults ? 'Gdio Foia' : nil))
+          state = (overrides.delete(:state) || (set_defaults ? 'FL' : nil))
+          zip = (overrides.delete(:zip) || (set_defaults ? 49302 : nil))
+          country = (overrides.delete(:country) || (set_defaults ? 'US' : nil))
+          cc_verification_value = (overrides.delete(:cc_verification_value) || (set_defaults ? 1234 : nil))
 
           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? ? Time.now.to_i.to_s + '-test@tester.com' : account.email) # Required by e.g. CyberSource
-          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)
+          properties << build_property('ccNumber', cc_number)
+          properties << build_property('ccFirstName', cc_first_name)
+          properties << build_property('ccLastName', cc_last_name)
+          properties << build_property('ccType', cc_type)
+          properties << build_property('ccExpirationMonth', cc_exp_month)
+          properties << build_property('ccExpirationYear', cc_exp_year)
+          properties << build_property('ccLast4', cc_last_4)
+          properties << build_property('email', account.nil? ? Time.now.to_i.to_s + '-test@tester.com' : account.email) # Required by e.g. CyberSource
+          properties << build_property('address1', address1)
+          properties << build_property('address2', address2)
+          properties << build_property('city', city)
+          properties << build_property('state', state)
+          properties << build_property('zip', zip)
+          properties << build_property('country', country)
+          properties << build_property('ccVerificationValue', cc_verification_value)
 
           overrides.each do |key, value|
-            properties << create_pm_kv_info(key, value)
+            properties << build_property(key, value)
           end
 
           properties
         end
 
-        def create_kb_account(kb_account_id)
+        def create_kb_account(kb_account_id, account_api = @account_api)
           external_key = Time.now.to_i.to_s + '-test'
           email = external_key + '@tester.com'
 
@@ -85,16 +86,33 @@ module Killbill
           account.name = 'Integration spec'
           account.currency = :USD
 
-          @account_api.accounts << account
+          account_api.accounts << account
 
           return external_key, kb_account_id
         end
 
-        def create_pm_kv_info(key, value)
-          prop = ::Killbill::Plugin::Model::PluginProperty.new
-          prop.key = key
-          prop.value = value
-          prop
+        def build_call_context(tenant_id = '00000011-0022-0033-0044-000000000055')
+          call_context = ::Killbill::Plugin::Model::CallContext.new
+          call_context.tenant_id = tenant_id
+          call_context.to_ruby(call_context)
+        end
+
+        def build_plugin(model, name, conf_dir = '.')
+          plugin = model.new
+
+          svcs = {
+              :account_user_api => ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaUserAccountApi.new,
+              :payment_api => ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaPaymentApi.new,
+              :tenant_user_api => ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaTenantUserApi.new
+          }
+          plugin.kb_apis = ::Killbill::Plugin::KillbillApi.new(name, svcs)
+
+          plugin.logger = ::Logger.new(STDOUT)
+          plugin.logger.level = ::Logger::INFO
+          plugin.conf_dir = File.expand_path(conf_dir)
+          plugin.root = "/foo/killbill-#{name}/0.0.1"
+
+          plugin
         end
 
         class FakeJavaUserAccountApi
@@ -149,7 +167,7 @@ module Killbill
 
           attr_accessor :per_tenant_config
 
-          def initialize(per_tenant_config)
+          def initialize(per_tenant_config = {})
             @per_tenant_config = per_tenant_config
           end
 

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

@@ -8,6 +8,8 @@ module Killbill
       require 'offsite_payments'
 
       class PaymentPlugin < ::Killbill::Plugin::Payment
+        include ::Killbill::Plugin::ActiveMerchant::ActiveRecordHelper
+        include ::Killbill::Plugin::PropertiesHelper
 
         def initialize(gateway_builder, identifier, payment_method_model, transaction_model, response_model)
           super()
@@ -17,11 +19,9 @@ module Killbill
           @payment_method_model = payment_method_model
           @transaction_model    = transaction_model
           @response_model       = response_model
-
         end
 
         def start_plugin
-
           @logger.progname = "#{@identifier.to_s}-plugin"
 
           @config_key_name = "PLUGIN_CONFIG_#{@plugin_name}".to_sym
@@ -37,19 +37,11 @@ module Killbill
           @logger.info "#{@identifier} payment plugin started"
         end
 
-        # return DB connections to the Pool if required
         def after_request
-          pool = ::ActiveRecord::Base.connection_pool
-          return unless pool.active_connection?
-
-          connection = ::ActiveRecord::Base.connection
-          pool.remove(connection)
-          connection.disconnect!
-
-          @logger.debug { "after_request: pool.active_connection? = #{pool.active_connection?}, connection.active? = #{connection.active?}, pool.connections.size = #{pool.connections.size}, connections = #{pool.connections.inspect}" }
+          # return DB connections to the Pool if required
+          close_connection(@logger)
         end
 
-
         def on_event(event)
           if (event.event_type == :TENANT_CONFIG_CHANGE || event.event_type == :TENANT_CONFIG_DELETION) &&
               event.meta_data.to_sym == @config_key_name
@@ -147,8 +139,8 @@ module Killbill
 
         def get_payment_info(kb_account_id, kb_payment_id, properties, context)
           # We assume the payment is immutable in the Gateway and only look at our tables
-          @transaction_model.transactions_from_kb_payment_id(kb_payment_id, context.tenant_id).collect do |transaction|
-            transaction.send("#{@identifier}_response").to_transaction_info_plugin(transaction)
+          @response_model.from_kb_payment_id(@transaction_model, kb_payment_id, context.tenant_id).collect do |response|
+            response.to_transaction_info_plugin(response.send("#{@identifier}_transaction"))
           end
         end
 
@@ -163,8 +155,10 @@ module Killbill
           options[:set_default] ||= set_default
           options[:order_id]    ||= kb_payment_method_id
 
+          should_skip_gw = Utils.normalized(options, :skip_gw)
+
           # Registering a card or a token
-          if options[:skip_gw]
+          if should_skip_gw
             # If nothing is passed, that's fine -  we probably just want a placeholder row in the plugin
             payment_source = get_payment_source(nil, all_properties, options, context) rescue nil
           else
@@ -172,21 +166,31 @@ module Killbill
           end
 
           # Go to the gateway
-          payment_processor_account_id = options[:payment_processor_account_id] || :default
+          payment_processor_account_id = Utils.normalized(options, :payment_processor_account_id) || :default
           gateway                      = lookup_gateway(payment_processor_account_id, context.tenant_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 (either a token or the full credit card)
-            if options[:skip_gw]
+            if should_skip_gw
               cc_or_token = payment_source
             else
               # response.authorization may be a String combination separated by ; - don't split it! Some plugins expect it as-is (they split it themselves)
               cc_or_token = response.authorization
             end
 
-            payment_method = @payment_method_model.from_response(kb_account_id, kb_payment_method_id, context.tenant_id, cc_or_token, gw_response, options, {}, @payment_method_model)
+            attributes = properties_to_hash(all_properties)
+            # Note: keep the same keys as in build_am_credit_card below
+            extra_params = {
+                :cc_first_name => Utils.normalized(attributes, :cc_first_name),
+                :cc_last_name => Utils.normalized(attributes, :cc_last_name),
+                :cc_type => Utils.normalized(attributes, :cc_type),
+                :cc_exp_month => Utils.normalized(attributes, :cc_expiration_month),
+                :cc_exp_year => Utils.normalized(attributes, :cc_expiration_year),
+                :cc_last_4 => Utils.normalized(attributes, :cc_last_4)
+            }
+            payment_method = @payment_method_model.from_response(kb_account_id, kb_payment_method_id, context.tenant_id, cc_or_token, gw_response, options, extra_params, @payment_method_model)
             payment_method.save!
             payment_method
           else
@@ -200,10 +204,12 @@ module Killbill
           pm      = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
           # Delete the card
-          payment_processor_account_id = options[:payment_processor_account_id] || :default
+          payment_processor_account_id = Utils.normalized(options, :payment_processor_account_id) || :default
           gateway                      = lookup_gateway(payment_processor_account_id, context.tenant_id)
-          if options[:customer_id]
-            gw_response = gateway.unstore(options[:customer_id], pm.token, options)
+
+          customer_id = Utils.normalized(options, :customer_id)
+          if customer_id
+            gw_response = gateway.unstore(customer_id, pm.token, options)
           else
             gw_response = gateway.unstore(pm.token, options)
           end
@@ -266,10 +272,12 @@ module Killbill
 
           # 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,
+            pm = @payment_method_model.create(:kb_account_id        => kb_account_id,
                                               :kb_payment_method_id => payment_method_info_plugin.payment_method_id,
                                               :kb_tenant_id         => context.tenant_id,
-                                              :token                => payment_method_info_plugin.external_payment_method_id
+                                              :token                => payment_method_info_plugin.external_payment_method_id,
+                                              :created_at           => Time.now.utc,
+                                              :updated_at           => Time.now.utc)
           end
         end
 
@@ -370,12 +378,12 @@ module Killbill
         # * 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, linked_transaction_proc=nil)
-          kb_transaction        = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
+          kb_transaction        = Utils::LazyEvaluator.new { get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id) }
           amount_in_cents       = amount.nil? ? nil : to_cents(amount, currency)
 
           # Setup options for ActiveMerchant
           options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_transaction.external_key
+          options[:order_id]    ||= (Utils.normalized(options, :external_key_as_order_id) ? kb_transaction.external_key : kb_payment_transaction_id)
           options[:currency]    ||= currency.to_s.upcase unless currency.nil?
           options[:description] ||= "Kill Bill #{operation.to_s} for #{kb_payment_transaction_id}"
 
@@ -388,7 +396,7 @@ module Killbill
           end
 
           # 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
+          last_transaction = Utils::LazyEvaluator.new { @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
@@ -404,7 +412,13 @@ module Killbill
           gw_responses                  = []
           responses                     = []
           transactions                  = []
-          payment_processor_account_ids = options[:payment_processor_account_ids].nil? ? [options[:payment_processor_account_id] || :default] : options[:payment_processor_account_ids].split(',')
+
+          payment_processor_account_ids = Utils.normalized(options, :payment_processor_account_ids)
+          if !payment_processor_account_ids
+            payment_processor_account_ids = [Utils.normalized(options, :payment_processor_account_id) || :default]
+          else
+            payment_processor_account_ids = payment_processor_account_ids.split(',')
+          end
           payment_processor_account_ids.each do |payment_processor_account_id|
             # Find the gateway
             gateway = lookup_gateway(payment_processor_account_id, context.tenant_id)
@@ -459,53 +473,51 @@ module Killbill
         end
 
         def get_payment_source(kb_payment_method_id, properties, options, context)
-          # Use ccNumber for the real number (if stored locally) or an in-house token (proxy tokenization). It is assumed the rest
-          # of the card details are filled (expiration dates, etc.).
-          cc_number   = find_value_from_properties(properties, 'ccNumber')
+          attributes = properties_to_hash(properties, options)
+
+          # Use ccNumber for:
+          # * the real number
+          # * in-house token (e.g. proxy tokenization)
+          # * token from a token service provider (e.g. ApplePay)
+          # If not specified, the rest of the card details will be retrieved from the locally stored payment method (if available)
+          cc_number = Utils.normalized(attributes, :cc_number)
           # Use token for the token stored in an external vault. The token itself should be enough to process payments.
-          cc_or_token = find_value_from_properties(properties, 'token') || find_value_from_properties(properties, 'cardId')
-
-          if cc_number.blank? and cc_or_token.blank?
-            # Lookup existing token
-            pm = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
-            if pm.token.nil?
-              # Real credit card
-              cc_or_token = ::ActiveMerchant::Billing::CreditCard.new(
-                  :number             => pm.cc_number,
-                  :brand              => pm.cc_type,
-                  :month              => pm.cc_exp_month,
-                  :year               => pm.cc_exp_year,
-                  :verification_value => pm.cc_verification_value,
-                  :first_name         => pm.cc_first_name,
-                  :last_name          => pm.cc_last_name
-              )
+          token = Utils.normalized(attributes, :token) || Utils.normalized(attributes, :card_id) || Utils.normalized(attributes, :payment_data)
+
+          if token.blank?
+            pm = nil
+            begin
+              pm = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
+            rescue => e
+              raise e if cc_number.blank?
+            end unless kb_payment_method_id.nil?
+
+            if cc_number.blank? && !pm.nil?
+              # Lookup existing token
+              if pm.token.nil?
+                # Real credit card
+                cc_or_token = build_am_credit_card(pm.cc_number, attributes, pm)
+              else
+                # Tokenized card
+                cc_or_token = pm.token
+              end
             else
-              # Tokenized card
-              cc_or_token = pm.token
+              # Real credit card or network tokenization
+              cc_or_token = build_am_credit_card(cc_number, attributes, pm)
             end
-          elsif !cc_number.blank? and cc_or_token.blank?
-            # Real credit card
-            cc_or_token = ::ActiveMerchant::Billing::CreditCard.new(
-                :number             => cc_number,
-                :brand              => find_value_from_properties(properties, 'ccType'),
-                :month              => find_value_from_properties(properties, 'ccExpirationMonth'),
-                :year               => find_value_from_properties(properties, 'ccExpirationYear'),
-                :verification_value => find_value_from_properties(properties, 'ccVerificationValue'),
-                :first_name         => find_value_from_properties(properties, 'ccFirstName'),
-                :last_name          => find_value_from_properties(properties, 'ccLastName')
-            )
           else
             # Use specified token
+            cc_or_token = build_am_token(token, attributes)
           end
 
           options[:billing_address] ||= {
-              :email    => find_value_from_properties(properties, 'email'),
-              :address1 => find_value_from_properties(properties, 'address1'),
-              :address2 => find_value_from_properties(properties, 'address2'),
-              :city     => find_value_from_properties(properties, 'city'),
-              :zip      => find_value_from_properties(properties, 'zip'),
-              :state    => find_value_from_properties(properties, 'state'),
-              :country  => find_value_from_properties(properties, 'country')
+              :email => Utils.normalized(attributes, :email),
+              :address1 => Utils.normalized(attributes, :address1) || (pm.nil? ? nil : pm.address1),
+              :address2 => Utils.normalized(attributes, :address2) || (pm.nil? ? nil : pm.address2),
+              :city => Utils.normalized(attributes, :city) || (pm.nil? ? nil : pm.city),
+              :zip => Utils.normalized(attributes, :zip) || (pm.nil? ? nil : pm.zip),
+              :state => Utils.normalized(attributes, :state) || (pm.nil? ? nil : pm.state),
+              :country => Utils.normalized(attributes, :country) || (pm.nil? ? nil : pm.country)
           }
 
           # To make various gateway implementations happy...
@@ -514,10 +526,49 @@ module Killbill
           cc_or_token
         end
 
-        def find_value_from_properties(properties, key)
-          return nil if key.nil?
-          prop = (properties.find { |kv| kv.key.to_s == key.to_s })
-          prop.nil? ? nil : prop.value
+        def build_am_credit_card(cc_number, attributes, pm=nil)
+          card_attributes = {
+              :number => cc_number,
+              :brand => Utils.normalized(attributes, :cc_type) || (pm.nil? ? nil : pm.cc_type),
+              :month => Utils.normalized(attributes, :cc_expiration_month) || (pm.nil? ? nil : pm.cc_exp_month),
+              :year => Utils.normalized(attributes, :cc_expiration_year) || (pm.nil? ? nil : pm.cc_exp_year),
+              :verification_value => Utils.normalized(attributes, :cc_verification_value) || (pm.nil? ? nil : pm.cc_verification_value),
+              :first_name => Utils.normalized(attributes, :cc_first_name) || (pm.nil? ? nil : pm.cc_first_name),
+              :last_name => Utils.normalized(attributes, :cc_last_name) || (pm.nil? ? nil : pm.cc_last_name)
+          }
+          tokenization_attributes = {
+              :eci => Utils.normalized(attributes, :eci),
+              :payment_cryptogram => Utils.normalized(attributes, :payment_cryptogram),
+              :transaction_id => Utils.normalized(attributes, :transaction_id)
+          }
+
+          if tokenization_attributes[:eci].nil? &&
+              tokenization_attributes[:payment_cryptogram].nil? &&
+              tokenization_attributes[:transaction_id].nil?
+            ::ActiveMerchant::Billing::CreditCard.new(card_attributes)
+          else
+            # NetworkTokenizationCreditCard is exactly like a credit card but with EMV/3DS standard payment network tokenization data
+            ::ActiveMerchant::Billing::NetworkTokenizationCreditCard.new(card_attributes.merge(tokenization_attributes))
+          end
+        end
+
+        def build_am_token(token, attributes)
+          token_attributes = {
+              :payment_instrument_name => Utils.normalized(attributes, :payment_instrument_name),
+              :payment_network => Utils.normalized(attributes, :payment_network),
+              :transaction_identifier => Utils.normalized(attributes, :transaction_identifier)
+          }
+
+          if token_attributes[:payment_instrument_name].nil? &&
+              token_attributes[:payment_network].nil? &&
+              token_attributes[:transaction_identifier].nil?
+            token
+          else
+            # Use ActiveSupport since ActiveMerchant does the same
+            payment_data = ::ActiveSupport::JSON.decode(token) rescue token
+            # PaymentToken is meant for modeling proprietary payment token structures (like stripe and apple_pay)
+            ::ActiveMerchant::Billing::ApplePayPaymentToken.new(payment_data, token_attributes)
+          end
         end
 
         def account_currency(kb_account_id, kb_tenant_id)
@@ -545,31 +596,6 @@ module Killbill
           ::Killbill::Plugin::ActiveMerchant.config
         end
 
-        def hash_to_properties(options)
-          merge_properties([], options)
-        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
-
         def get_active_merchant_module
           ::OffsitePayments.integration(@identifier.to_s.camelize)
         end