activemerchant 1.38.0 → 1.79.2

data/lib/active_merchant/billing/gateways/braintree_blue.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/braintree/braintree_common'
+require 'active_merchant/billing/gateways/braintree/braintree_common'
 
 begin
   require "braintree"
@@ -6,7 +6,9 @@ rescue LoadError
   raise "Could not load the braintree gem.  Use `gem install braintree` to install it."
 end
 
-raise "Need braintree gem 2.x.y. Run `gem install braintree --version '~>2.0'` to get the correct version." unless Braintree::Version::Major == 2
+unless Braintree::Version::Major == 2 && Braintree::Version::Minor >= 78
+  raise "Need braintree gem >= 2.78.0. Run `gem install braintree --version '~>2.78'` to get the correct version."
+end
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -23,56 +25,51 @@ module ActiveMerchant #:nodoc:
     # Setting an ActiveMerchant +wiredump_device+ will automatically
     # configure the Braintree logger (via the Braintree gem's
     # configuration) when the BraintreeBlueGateway is instantiated.
-    # Additionally, the log level will be set to +DEBUG+.  Therefore,
-    # all you have to do is set the +wiredump_device+ and you'll
-    # get your debug output from your HTTP interactions with the
-    # remote gateway. (Don't enable this in production.)
-    #
-    # For example:
-    #
-    #     ActiveMerchant::Billing::BraintreeBlueGateway.wiredump_device = Logger.new(STDOUT)
-    #     # => #<Logger:0x107d385f8 ...>
-    #
-    #     Braintree::Configuration.logger
-    #     # => (some other logger, created by default by the gem)
-    #
-    #     Braintree::Configuration.logger.level
-    #     # => 1 (INFO)
+    # Additionally, the log level will be set to +DEBUG+. Therefore,
+    # all you have to do is set the +wiredump_device+ and you'll get
+    # your debug output from your HTTP interactions with the remote
+    # gateway. (Don't enable this in production.) The ActiveMerchant
+    # implementation doesn't mess with the Braintree::Configuration
+    # globals at all, so there won't be any side effects outside
+    # Active Merchant.
     #
-    #     ActiveMerchant::Billing::BraintreeBlueGateway.new(:merchant_id => 'x', :public_key => 'x', :private_key => 'x')
+    # If no +wiredump_device+ is set, the logger in
+    # +Braintree::Configuration.logger+ will be cloned and the log
+    # level set to +WARN+.
     #
-    #     Braintree::Configuration.logger
-    #     # => #<Logger:0x107d385f8 ...>
-    #
-    #     Braintree::Configuration.logger.level
-    #     # => 0 (DEBUG)
-    #
-    #  Alternatively, you can avoid setting the +wiredump_device+
-    #  and set +Braintree::Configuration.logger+ and/or
-    #  +Braintree::Configuration.logger.level+ directly.
     class BraintreeBlueGateway < Gateway
       include BraintreeCommon
 
       self.display_name = 'Braintree (Blue Platform)'
 
+      ERROR_CODES = {
+        cannot_refund_if_unsettled: 91506
+      }
+
       def initialize(options = {})
         requires!(options, :merchant_id, :public_key, :private_key)
         @merchant_account_id = options[:merchant_account_id]
 
         super
 
-        Braintree::Configuration.merchant_id = options[:merchant_id]
-        Braintree::Configuration.public_key = options[:public_key]
-        Braintree::Configuration.private_key = options[:private_key]
-        Braintree::Configuration.environment = (options[:environment] || (test? ? :sandbox : :production)).to_sym
-        Braintree::Configuration.custom_user_agent = "ActiveMerchant #{ActiveMerchant::VERSION}"
-
-        if wiredump_device
-          Braintree::Configuration.logger = ((Logger === wiredump_device) ? wiredump_device : Logger.new(wiredump_device))
-          Braintree::Configuration.logger.level = Logger::DEBUG
+        if wiredump_device.present?
+          logger = ((Logger === wiredump_device) ? wiredump_device : Logger.new(wiredump_device))
+          logger.level = Logger::DEBUG
         else
-          Braintree::Configuration.logger.level = Logger::WARN
+          logger = Braintree::Configuration.logger.clone
+          logger.level = Logger::WARN
         end
+
+        @configuration = Braintree::Configuration.new(
+          :merchant_id       => options[:merchant_id],
+          :public_key        => options[:public_key],
+          :private_key       => options[:private_key],
+          :environment       => (options[:environment] || (test? ? :sandbox : :production)).to_sym,
+          :custom_user_agent => "ActiveMerchant #{ActiveMerchant::VERSION}",
+          :logger            => options[:logger] || logger,
+        )
+
+        @braintree_gateway = Braintree::Gateway.new( @configuration )
       end
 
       def authorize(money, credit_card_or_vault_id, options = {})
@@ -81,8 +78,8 @@ module ActiveMerchant #:nodoc:
 
       def capture(money, authorization, options = {})
         commit do
-          result = Braintree::Transaction.submit_for_settlement(authorization, amount(money).to_s)
-          Response.new(result.success?, message_from_result(result))
+          result = @braintree_gateway.transaction.submit_for_settlement(authorization, localized_amount(money, options[:currency] || default_currency).to_s)
+          response_from_result(result)
         end
       end
 
@@ -97,61 +94,59 @@ module ActiveMerchant #:nodoc:
       def refund(*args)
         # legacy signature: #refund(transaction_id, options = {})
         # new signature: #refund(money, transaction_id, options = {})
-        money, transaction_id, _ = extract_refund_args(args)
-        money = amount(money).to_s if money
+        money, transaction_id, options = extract_refund_args(args)
+        money = localized_amount(money, options[:currency] || default_currency).to_s if money
 
         commit do
-          result = Braintree::Transaction.refund(transaction_id, money)
-          Response.new(result.success?, message_from_result(result),
-            {:braintree_transaction => (transaction_hash(result.transaction) if result.success?)},
-            {:authorization => (result.transaction.id if result.success?)}
-           )
+          response = response_from_result(@braintree_gateway.transaction.refund(transaction_id, money))
+          return response if response.success?
+          return response unless options[:force_full_refund_if_unsettled]
+
+          void(transaction_id) if response.message =~ /#{ERROR_CODES[:cannot_refund_if_unsettled]}/
         end
       end
 
       def void(authorization, options = {})
         commit do
-          result = Braintree::Transaction.void(authorization)
-          Response.new(result.success?, message_from_result(result),
-            {:braintree_transaction => (transaction_hash(result.transaction) if result.success?)},
-            {:authorization => (result.transaction.id if result.success?)}
-          )
+          response_from_result(@braintree_gateway.transaction.void(authorization))
+        end
+      end
+
+      def verify(credit_card, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
 
       def store(creditcard, options = {})
-        commit do
-          parameters = {
-            :first_name => creditcard.first_name,
-            :last_name => creditcard.last_name,
-            :email => options[:email],
-            :credit_card => {
-              :number => creditcard.number,
-              :cvv => creditcard.verification_value,
-              :expiration_month => creditcard.month.to_s.rjust(2, "0"),
-              :expiration_year => creditcard.year.to_s
-            }
-          }
-          result = Braintree::Customer.create(merge_credit_card_options(parameters, options))
-          Response.new(result.success?, message_from_result(result),
-            {
-              :braintree_customer => (customer_hash(result.customer) if result.success?),
-              :customer_vault_id => (result.customer.id if result.success?)
-            },
-            :authorization => (result.customer.id if result.success?)
-          )
+        if options[:customer].present?
+          MultiResponse.new.tap do |r|
+            customer_exists_response = nil
+            r.process{customer_exists_response = check_customer_exists(options[:customer])}
+            r.process do
+              if customer_exists_response.params["exists"]
+                add_credit_card_to_customer(creditcard, options)
+              else
+                add_customer_with_credit_card(creditcard, options)
+              end
+            end
+          end
+        else
+          add_customer_with_credit_card(creditcard, options)
         end
       end
 
       def update(vault_id, creditcard, options = {})
         braintree_credit_card = nil
         commit do
-          braintree_credit_card = Braintree::Customer.find(vault_id).credit_cards.detect { |cc| cc.default? }
+          braintree_credit_card = @braintree_gateway.customer.find(vault_id).credit_cards.detect { |cc| cc.default? }
           return Response.new(false, 'Braintree::NotFoundError') if braintree_credit_card.nil?
 
           options.merge!(:update_existing_token => braintree_credit_card.token)
           credit_card_params = merge_credit_card_options({
             :credit_card => {
+              :cardholder_name => creditcard.name,
               :number => creditcard.number,
               :cvv => creditcard.verification_value,
               :expiration_month => creditcard.month.to_s.rjust(2, "0"),
@@ -159,14 +154,16 @@ module ActiveMerchant #:nodoc:
             }
           }, options)[:credit_card]
 
-          result = Braintree::Customer.update(vault_id,
+          result = @braintree_gateway.customer.update(vault_id,
             :first_name => creditcard.first_name,
             :last_name => creditcard.last_name,
-            :email => options[:email],
+            :email => scrub_email(options[:email]),
+            :phone => options[:phone] || (options[:billing_address][:phone] if options[:billing_address] &&
+				      options[:billing_address][:phone]),
             :credit_card => credit_card_params
           )
           Response.new(result.success?, message_from_result(result),
-            :braintree_customer => (customer_hash(Braintree::Customer.find(vault_id)) if result.success?),
+            :braintree_customer => (customer_hash(@braintree_gateway.customer.find(vault_id), :include_credit_cards) if result.success?),
             :customer_vault_id => (result.customer.id if result.success?)
           )
         end
@@ -174,20 +171,135 @@ module ActiveMerchant #:nodoc:
 
       def unstore(customer_vault_id, options = {})
         commit do
-          Braintree::Customer.delete(customer_vault_id)
+          if(!customer_vault_id && options[:credit_card_token])
+            @braintree_gateway.credit_card.delete(options[:credit_card_token])
+          else
+            @braintree_gateway.customer.delete(customer_vault_id)
+          end
           Response.new(true, "OK")
         end
       end
       alias_method :delete, :unstore
 
+      def supports_network_tokenization?
+        true
+      end
+
+      def verify_credentials
+        begin
+          @braintree_gateway.transaction.find("non_existent_token")
+        rescue Braintree::AuthenticationError
+          return false
+        rescue Braintree::NotFoundError
+          return true
+        end
+
+        true
+      end
+
       private
 
+      def check_customer_exists(customer_vault_id)
+        commit do
+          begin
+            @braintree_gateway.customer.find(customer_vault_id)
+            ActiveMerchant::Billing::Response.new(true, "Customer found", {exists: true}, authorization: customer_vault_id)
+          rescue Braintree::NotFoundError
+            ActiveMerchant::Billing::Response.new(true, "Customer not found", {exists: false})
+          end
+        end
+      end
+
+      def add_customer_with_credit_card(creditcard, options)
+        commit do
+          if options[:payment_method_nonce]
+            credit_card_params = { payment_method_nonce: options[:payment_method_nonce] }
+          else
+            credit_card_params = {
+              :credit_card => {
+                :cardholder_name => creditcard.name,
+                :number => creditcard.number,
+                :cvv => creditcard.verification_value,
+                :expiration_month => creditcard.month.to_s.rjust(2, "0"),
+                :expiration_year => creditcard.year.to_s,
+                :token => options[:credit_card_token]
+              }
+            }
+          end
+          parameters = {
+            :first_name => creditcard.first_name,
+            :last_name => creditcard.last_name,
+            :email => scrub_email(options[:email]),
+            :phone => options[:phone] || (options[:billing_address][:phone] if options[:billing_address] &&
+	            options[:billing_address][:phone]),
+            :id => options[:customer],
+          }.merge credit_card_params
+          result = @braintree_gateway.customer.create(merge_credit_card_options(parameters, options))
+          Response.new(result.success?, message_from_result(result),
+            {
+              :braintree_customer => (customer_hash(result.customer, :include_credit_cards) if result.success?),
+              :customer_vault_id => (result.customer.id if result.success?),
+              :credit_card_token => (result.customer.credit_cards[0].token if result.success?)
+            },
+            :authorization => (result.customer.id if result.success?)
+          )
+        end
+      end
+
+      def add_credit_card_to_customer(credit_card, options)
+        commit do
+          parameters = {
+            customer_id: options[:customer],
+            token: options[:credit_card_token],
+            cardholder_name: credit_card.name,
+            number: credit_card.number,
+            cvv: credit_card.verification_value,
+            expiration_month: credit_card.month.to_s.rjust(2, "0"),
+            expiration_year: credit_card.year.to_s,
+          }
+          parameters[:billing_address] = map_address(options[:billing_address]) if options[:billing_address]
+
+          result = @braintree_gateway.credit_card.create(parameters)
+          ActiveMerchant::Billing::Response.new(
+            result.success?,
+            message_from_result(result),
+            {
+              customer_vault_id: (result.credit_card.customer_id if result.success?),
+              credit_card_token: (result.credit_card.token if result.success?)
+            },
+            authorization: (result.credit_card.customer_id if result.success?)
+          )
+        end
+      end
+
+      def scrub_email(email)
+        return nil unless email.present?
+        return nil if (
+          email !~ /^.+@[^\.]+(\.[^\.]+)+[a-z]$/i ||
+          email =~ /\.(con|met)$/i
+        )
+        email
+      end
+
+      def scrub_zip(zip)
+        return nil unless zip.present?
+        return nil if(
+          zip.gsub(/[^a-z0-9]/i, '').length > 9 ||
+          zip =~ /[^a-z0-9\- ]/i
+        )
+        zip
+      end
+
       def merge_credit_card_options(parameters, options)
         valid_options = {}
         options.each do |key, value|
           valid_options[key] = value if [:update_existing_token, :verify_card, :verification_merchant_account_id].include?(key)
         end
 
+        if valid_options.include?(:verify_card) && @merchant_account_id
+          valid_options[:verification_merchant_account_id] ||= @merchant_account_id
+        end
+
         parameters[:credit_card] ||= {}
         parameters[:credit_card].merge!(:options => valid_options)
         parameters[:credit_card][:billing_address] = map_address(options[:billing_address]) if options[:billing_address]
@@ -202,9 +314,9 @@ module ActiveMerchant #:nodoc:
           :company => address[:company],
           :locality => address[:city],
           :region => address[:state],
-          :postal_code => address[:zip],
+          :postal_code => scrub_zip(address[:zip]),
         }
-        if(address[:country] || address[:country_code_alpha2])
+        if (address[:country] || address[:country_code_alpha2])
           mapped[:country_code_alpha2] = (address[:country] || address[:country_code_alpha2])
         elsif address[:country_name]
           mapped[:country_name] = address[:country_name]
@@ -225,40 +337,103 @@ module ActiveMerchant #:nodoc:
       def message_from_result(result)
         if result.success?
           "OK"
-        elsif result.errors.size == 0 && result.credit_card_verification
+        elsif result.errors.any?
+          result.errors.map { |e| "#{e.message} (#{e.code})" }.join(" ")
+        elsif result.credit_card_verification
           "Processor declined: #{result.credit_card_verification.processor_response_text} (#{result.credit_card_verification.processor_response_code})"
         else
-          result.errors.map { |e| "#{e.message} (#{e.code})" }.join(" ")
+          result.message.to_s
+        end
+      end
+
+      def response_from_result(result)
+        Response.new(result.success?, message_from_result(result),
+          { braintree_transaction: transaction_hash(result) },
+          { authorization: (result.transaction.id if result.transaction) }
+         )
+      end
+
+      def response_params(result)
+        params = {}
+        params[:customer_vault_id] = result.transaction.customer_details.id if result.success?
+        params[:braintree_transaction] = transaction_hash(result)
+        params
+      end
+
+      def response_options(result)
+        options = {}
+        if result.transaction
+          options[:authorization] = result.transaction.id
+          options[:avs_result] = { code: avs_code_from(result.transaction) }
+          options[:cvv_result] = result.transaction.cvv_response_code
+        end
+        options
+      end
+
+      def avs_code_from(transaction)
+        transaction.avs_error_response_code ||
+          avs_mapping["street: #{transaction.avs_street_address_response_code}, zip: #{transaction.avs_postal_code_response_code}"]
+      end
+
+      def avs_mapping
+        {
+          "street: M, zip: M" => "M",
+          "street: M, zip: N" => "A",
+          "street: M, zip: U" => "B",
+          "street: M, zip: I" => "B",
+          "street: M, zip: A" => "B",
+
+          "street: N, zip: M" => "Z",
+          "street: N, zip: N" => "C",
+          "street: N, zip: U" => "C",
+          "street: N, zip: I" => "C",
+          "street: N, zip: A" => "C",
+
+          "street: U, zip: M" => "P",
+          "street: U, zip: N" => "N",
+          "street: U, zip: U" => "I",
+          "street: U, zip: I" => "I",
+          "street: U, zip: A" => "I",
+
+          "street: I, zip: M" => "P",
+          "street: I, zip: N" => "C",
+          "street: I, zip: U" => "I",
+          "street: I, zip: I" => "I",
+          "street: I, zip: A" => "I",
+
+          "street: A, zip: M" => "P",
+          "street: A, zip: N" => "C",
+          "street: A, zip: U" => "I",
+          "street: A, zip: I" => "I",
+          "street: A, zip: A" => "I"
+        }
+      end
+
+      def message_from_transaction_result(result)
+        if result.transaction && result.transaction.status == "gateway_rejected"
+          "Transaction declined - gateway rejected"
+        elsif result.transaction
+          "#{result.transaction.processor_response_code} #{result.transaction.processor_response_text}"
+        else
+          message_from_result(result)
+        end
+      end
+
+      def response_code_from_result(result)
+        if result.transaction
+          result.transaction.processor_response_code
+        elsif result.errors.size == 0 && result.credit_card_verification
+          result.credit_card_verification.processor_response_code
+        elsif result.errors.size > 0
+          result.errors.first.code
         end
       end
 
       def create_transaction(transaction_type, money, credit_card_or_vault_id, options)
         transaction_params = create_transaction_parameters(money, credit_card_or_vault_id, options)
-
         commit do
-          result = Braintree::Transaction.send(transaction_type, transaction_params)
-          response_params, response_options, avs_result, cvv_result = {}, {}, {}, {}
-          if result.success?
-            response_params[:braintree_transaction] = transaction_hash(result.transaction)
-            response_params[:customer_vault_id] = result.transaction.customer_details.id
-            response_options[:authorization] = result.transaction.id
-          end
-          if result.transaction
-            response_options[:avs_result] = {
-              :code => nil, :message => nil,
-              :street_match => result.transaction.avs_street_address_response_code,
-              :postal_match => result.transaction.avs_postal_code_response_code
-            }
-            response_options[:cvv_result] = result.transaction.cvv_response_code
-            if result.transaction.status == "gateway_rejected"
-              message = "Transaction declined - gateway rejected"
-            else
-              message = "#{result.transaction.processor_response_code} #{result.transaction.processor_response_text}"
-            end
-          else
-            message = message_from_result(result)
-          end
-          response = Response.new(result.success?, message, response_params, response_options)
+          result = @braintree_gateway.transaction.send(transaction_type, transaction_params)
+          response = Response.new(result.success?, message_from_transaction_result(result), response_params(result), response_options(result))
           response.cvv_result['message'] = ''
           response
         end
@@ -277,28 +452,37 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def customer_hash(customer)
-        credit_cards = customer.credit_cards.map do |cc|
-          {
-            "bin" => cc.bin,
-            "expiration_date" => cc.expiration_date,
-            "token" => cc.token,
-            "last_4" => cc.last_4,
-            "card_type" => cc.card_type,
-            "masked_number" => cc.masked_number
-          }
-        end
-
-        {
+      def customer_hash(customer, include_credit_cards=false)
+        hash = {
           "email" => customer.email,
+          "phone" => customer.phone,
           "first_name" => customer.first_name,
           "last_name" => customer.last_name,
-          "credit_cards" => credit_cards,
           "id" => customer.id
         }
+
+        if include_credit_cards
+          hash["credit_cards"] = customer.credit_cards.map do |cc|
+            {
+              "bin" => cc.bin,
+              "expiration_date" => cc.expiration_date,
+              "token" => cc.token,
+              "last_4" => cc.last_4,
+              "card_type" => cc.card_type,
+              "masked_number" => cc.masked_number
+            }
+          end
+        end
+
+        hash
       end
 
-      def transaction_hash(transaction)
+      def transaction_hash(result)
+        unless result.success?
+          return { "processor_response_code" => response_code_from_result(result) }
+        end
+
+        transaction = result.transaction
         if transaction.vault_customer
           vault_customer = {
           }
@@ -313,7 +497,8 @@ module ActiveMerchant #:nodoc:
 
         customer_details = {
           "id" => transaction.customer_details.id,
-          "email" => transaction.customer_details.email
+          "email" => transaction.customer_details.email,
+          "phone" => transaction.customer_details.phone,
         }
 
         billing_details = {
@@ -344,31 +529,43 @@ module ActiveMerchant #:nodoc:
         }
 
         {
-          "order_id"            => transaction.order_id,
-          "status"              => transaction.status,
-          "credit_card_details" => credit_card_details,
-          "customer_details"    => customer_details,
-          "billing_details"     => billing_details,
-          "shipping_details"    => shipping_details,
-          "vault_customer"      => vault_customer,
-          "merchant_account_id" => transaction.merchant_account_id
+          "order_id"                => transaction.order_id,
+          "amount"                  => transaction.amount.to_s,
+          "status"                  => transaction.status,
+          "credit_card_details"     => credit_card_details,
+          "customer_details"        => customer_details,
+          "billing_details"         => billing_details,
+          "shipping_details"        => shipping_details,
+          "vault_customer"          => vault_customer,
+          "merchant_account_id"     => transaction.merchant_account_id,
+          "processor_response_code" => response_code_from_result(result)
         }
       end
 
       def create_transaction_parameters(money, credit_card_or_vault_id, options)
         parameters = {
-          :amount => amount(money).to_s,
+          :amount => localized_amount(money, options[:currency] || default_currency).to_s,
           :order_id => options[:order_id],
           :customer => {
             :id => options[:store] == true ? "" : options[:store],
-            :email => options[:email]
+            :email => scrub_email(options[:email]),
+            :phone => options[:phone] || (options[:billing_address][:phone] if options[:billing_address] &&
+	            options[:billing_address][:phone])
           },
           :options => {
             :store_in_vault => options[:store] ? true : false,
-            :submit_for_settlement => options[:submit_for_settlement]
+            :submit_for_settlement => options[:submit_for_settlement],
+            :hold_in_escrow => options[:hold_in_escrow],
           }
         }
 
+        if options[:skip_advanced_fraud_checking]
+          parameters[:options].merge!({ :skip_advanced_fraud_checking => options[:skip_advanced_fraud_checking] })
+        end
+
+        parameters[:custom_fields] = options[:custom_fields]
+        parameters[:device_data] = options[:device_data] if options[:device_data]
+        parameters[:service_fee_amount] = options[:service_fee_amount] if options[:service_fee_amount]
         if merchant_account_id = (options[:merchant_account_id] || @merchant_account_id)
           parameters[:merchant_account_id] = merchant_account_id
         end
@@ -378,24 +575,75 @@ module ActiveMerchant #:nodoc:
         end
 
         if credit_card_or_vault_id.is_a?(String) || credit_card_or_vault_id.is_a?(Integer)
-          parameters[:customer_id] = credit_card_or_vault_id
+          if options[:payment_method_token]
+            parameters[:payment_method_token] = credit_card_or_vault_id
+            options.delete(:billing_address)
+          elsif options[:payment_method_nonce]
+            parameters[:payment_method_nonce] = credit_card_or_vault_id
+          else
+            parameters[:customer_id] = credit_card_or_vault_id
+          end
         else
           parameters[:customer].merge!(
             :first_name => credit_card_or_vault_id.first_name,
             :last_name => credit_card_or_vault_id.last_name
           )
-          parameters[:credit_card] = {
-            :number => credit_card_or_vault_id.number,
-            :cvv => credit_card_or_vault_id.verification_value,
-            :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
-            :expiration_year => credit_card_or_vault_id.year.to_s
-          }
+          if credit_card_or_vault_id.is_a?(NetworkTokenizationCreditCard)
+            if credit_card_or_vault_id.source == :apple_pay
+              parameters[:apple_pay_card] = {
+                :number => credit_card_or_vault_id.number,
+                :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
+                :expiration_year => credit_card_or_vault_id.year.to_s,
+                :cardholder_name => credit_card_or_vault_id.name,
+                :cryptogram => credit_card_or_vault_id.payment_cryptogram,
+                :eci_indicator => credit_card_or_vault_id.eci
+              }
+          elsif credit_card_or_vault_id.source == :android_pay
+              parameters[:android_pay_card] = {
+                :number => credit_card_or_vault_id.number,
+                :cryptogram => credit_card_or_vault_id.payment_cryptogram,
+                :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
+                :expiration_year => credit_card_or_vault_id.year.to_s,
+                :google_transaction_id => credit_card_or_vault_id.transaction_id,
+                :source_card_type => credit_card_or_vault_id.brand,
+                :source_card_last_four => credit_card_or_vault_id.last_digits,
+                :eci_indicator => credit_card_or_vault_id.eci
+              }
+            end
+          else
+            parameters[:credit_card] = {
+              :number => credit_card_or_vault_id.number,
+              :cvv => credit_card_or_vault_id.verification_value,
+              :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
+              :expiration_year => credit_card_or_vault_id.year.to_s,
+              :cardholder_name => credit_card_or_vault_id.name
+            }
+          end
         end
         parameters[:billing] = map_address(options[:billing_address]) if options[:billing_address]
         parameters[:shipping] = map_address(options[:shipping_address]) if options[:shipping_address]
+
+        channel = @options[:channel] || application_id
+        parameters[:channel] = channel if channel
+
+        if options[:descriptor_name] || options[:descriptor_phone] || options[:descriptor_url]
+          parameters[:descriptor] = {
+            name: options[:descriptor_name],
+            phone: options[:descriptor_phone],
+            url: options[:descriptor_url]
+          }
+        end
+
+        if options[:three_d_secure]
+          parameters[:three_d_secure_pass_thru] = {
+            cavv: options[:three_d_secure][:cavv],
+            eci_flag: options[:three_d_secure][:eci],
+            xid: options[:three_d_secure][:xid],
+          }
+        end
+
         parameters
       end
     end
   end
 end
-