activemerchant 1.62.0 → 1.63.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7495e19fc84deca42bc3878d9463044899a33b2e
-  data.tar.gz: bc44737020062ba81039dfc19956b7c5a128ee40
+  metadata.gz: a16e6e0f311ac3b77069a4f05f5f257b6a69fc60
+  data.tar.gz: 666b86bb155b6ff98a608bf8c38714a54af46627
 SHA512:
-  metadata.gz: 3fb5132fdfd23c6f1d772755285638231bef754099790c47c69f963133b7c1057c0d3c3f19b82c8b72226f5b61a294c7d2d30e283c570d2a5f81701886db491a
-  data.tar.gz: be95c7d4600244ab3f2607f2a67ff1f4a325db60da1deb57834b5ea11eead17392a4d5d758d5595fcd76710c2a3e141a51e61e0de67191db8b2be58b1b07e867
+  metadata.gz: bd479af93c39120f8a447058524d56de326189f0f3fc26ace5af2681166761fc81a967a66368f9d50e4d7a5a0b64c7a4867c7f61dc2b37e368b0aa19141c87c2
+  data.tar.gz: b9f8ea0507a585f672f9abce5cf4c2359dbeeb781fe8cdda5e05413aa24fa638fc25a0f83279c4143e72278f8cf4e82f12a1987190390640a7c21ff52f488389

data/CHANGELOG

@@ -2,6 +2,29 @@
 
 == HEAD
 
+== Version 1.63.0 (February 2, 2017)
+* Authorize.net: Add #unstore support [jimryan] #2293
+* AuthorizeNet: Fix line items quirk [shasum]
+* CardStream: Add dynamic descriptor option fields [curiousepic]
+* CardStream: Support PEN currency [shasum]
+* Culqi: Add new gateway [shasum]
+* CyberSource: Add Lebanon to supported countries [shasum]
+* Element: Add AVS and CVV codes to response [shasum]
+* Firstdata E4 (Payeezy): Set correct ECI value for card present swipes [jasonwebster] #2318
+* GlobalCollect: On purchase skip capture if not required [davidsantoso]
+* PaymentExpress: Update supported countries [shasum]
+* Remove leading or trailing whitespace from credit card name [davidsantoso]
+* Remove support for Ruby 2.0 [jasonwebster]
+* Secure Pay AU: Add scrubbing support to Secure Pay AU [bruno] #2253
+* Stripe: Fix error in handling of track-only contactless EMV data [jasonwebster]
+* Vanco: Update test URL [davidsantoso]
+* WePay: Build fee structure correctly [curiousepic]
+* WePay: Remove null address fields from request [davidsantoso]
+* WePay: Update WePay to API version 2016-12-07 [davidsantoso]
+* Wirecard: Send customer data in requests [davidsantoso]
+* Worldpay: Add session id attribute [shasum]
+* Worldpay: Do not default address when not provided [shasum]
+
 == Version 1.62.0 (December 5, 2016)
 * AuthorizeNet: Map to standard AVSResult codes [shasum]
 * CitrusPay: Add 3DSecureId field [davidsantoso]

data/lib/active_merchant/billing/credit_card.rb

@@ -245,7 +245,7 @@ module ActiveMerchant #:nodoc:
       #
       # @return [String] the full name of the card holder
       def name
-        [first_name, last_name].compact.join(' ')
+        "#{first_name} #{last_name}".strip
       end
 
       def name=(full_name)

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

@@ -159,7 +159,6 @@ module ActiveMerchant
             add_payment_source(xml, payment)
             add_invoice(xml, options)
             add_customer_data(xml, payment, options)
-            add_line_items(xml, options)
             add_settings(xml, payment, options)
             add_user_fields(xml, amount, options)
           end
@@ -181,6 +180,12 @@ module ActiveMerchant
         end
       end
 
+      def unstore(authorization)
+        customer_profile_id, _, _ = split_authorization(authorization)
+
+        delete_customer_profile(customer_profile_id)
+      end
+
       def verify_credentials
         response = commit(:verify_credentials) { }
         response.success?
@@ -233,7 +238,6 @@ module ActiveMerchant
           add_invoice(xml, options)
           add_customer_data(xml, payment, options)
           add_market_type_device_type(xml, payment, options)
-          add_line_items(xml, options)
           add_settings(xml, payment, options)
           add_user_fields(xml, amount, options)
         end
@@ -347,19 +351,6 @@ module ActiveMerchant
         end
       end
 
-      def add_line_items(xml, options)
-        return unless options[:line_items]
-        xml.lineItems do
-          options[:line_items].each do |line_item|
-            xml.lineItem do
-              line_item.each do |key, value|
-                xml.send(camel_case_lower(key), value)
-              end
-            end
-          end
-        end
-      end
-
       def camel_case_lower(key)
         String(key).split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
       end
@@ -575,6 +566,19 @@ module ActiveMerchant
           xml.invoiceNumber(truncate(options[:order_id], 20))
           xml.description(truncate(options[:description], 255))
         end
+
+        # Authorize.net API requires lineItems to be placed directly after order tag
+        if options[:line_items]
+          xml.lineItems do
+            options[:line_items].each do |line_item|
+              xml.lineItem do
+                line_item.each do |key, value|
+                  xml.send(camel_case_lower(key), value)
+                end
+              end
+            end
+          end
+        end
       end
 
       def create_customer_payment_profile(credit_card, options)
@@ -616,6 +620,12 @@ module ActiveMerchant
         end
       end
 
+      def delete_customer_profile(customer_profile_id)
+        commit(:cim_store_delete_customer) do |xml|
+          xml.customerProfileId(customer_profile_id)
+        end
+      end
+
       def names_from(payment_source, address, options)
         if payment_source && !payment_source.is_a?(PaymentToken) && !payment_source.is_a?(String)
           first_name, last_name = split_names(address[:name])
@@ -683,6 +693,8 @@ module ActiveMerchant
           "createCustomerProfileRequest"
         elsif action == :cim_store_update
           "createCustomerPaymentProfileRequest"
+        elsif action == :cim_store_delete_customer
+          "deleteCustomerProfileRequest"
         elsif action == :verify_credentials
           "authenticateTestRequest"
         elsif is_cim_action?(action)
@@ -827,7 +839,7 @@ module ActiveMerchant
       end
 
       def cim?(action)
-        (action == :cim_store) || (action == :cim_store_update)
+        (action == :cim_store) || (action == :cim_store_update) || (action == :cim_store_delete_customer)
       end
 
       def transaction_id_from(authorization)

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

@@ -28,6 +28,7 @@ module ActiveMerchant #:nodoc:
         "MXN" => "484",
         "NOK" => "578",
         "NZD" => "554",
+        "PEN" => "604",
         "SEK" => "752",
         "SGD" => "702",
         "USD" => "840",
@@ -154,6 +155,8 @@ module ActiveMerchant #:nodoc:
       def add_invoice(post, credit_card_or_reference, money, options)
         add_pair(post, :transactionUnique, options[:order_id], :required => true)
         add_pair(post, :orderRef, options[:description] || options[:order_id], :required => true)
+        add_pair(post, :statementNarrative1, options[:merchant_name]) if options[:merchant_name]
+        add_pair(post, :statementNarrative2, options[:dynamic_descriptor]) if options[:dynamic_descriptor]
         if credit_card_or_reference.respond_to?(:number)
           if ['american_express', 'diners_club'].include?(card_brand(credit_card_or_reference).to_s)
             add_pair(post, :item1Quantity, 1)

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

@@ -0,0 +1,279 @@
+require 'digest/md5'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Important note:
+    # ===
+    # Culqi merchant accounts are configured for either purchase or auth/capture
+    # modes. This is configured by Culqi when setting up a merchant account and
+    # largely depends on the transaction acquiring bank. Be sure to understand how
+    # your account was configured prior to using this gateway.
+    class CulqiGateway < Gateway
+      self.display_name = "Culqi"
+      self.homepage_url = "https://www.culqi.com"
+
+      self.test_url = "https://staging.paymentz.com/transaction/"
+      self.live_url = "https://secure.culqi.com/transaction/"
+
+      self.supported_countries = ["PE"]
+      self.default_currency = "PEN"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :diners_club, :american_express]
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :terminal_id, :secret_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        authorize(amount, payment_method, options)
+      end
+
+      def authorize(amount, payment_method, options={})
+        if payment_method.is_a?(String)
+          action = :tokenpay
+        else
+          action = :authorize
+        end
+        post = {}
+        add_credentials(post)
+        add_invoice(action, post, amount, options)
+        add_payment_method(post, payment_method, action, options)
+        add_customer_data(post, options)
+        add_checksum(action, post)
+
+        commit(action, post)
+      end
+
+      def capture(amount, authorization, options={})
+        action = :capture
+        post = {}
+        add_credentials(post)
+        add_invoice(action, post, amount, options)
+        add_reference(post, authorization)
+        add_checksum(action, post)
+
+        commit(action, post)
+      end
+
+      def void(authorization, options={})
+        action = :void
+        post = {}
+        add_credentials(post)
+        add_invoice(action, post, nil, options)
+        add_reference(post, authorization)
+        add_checksum(action, post)
+
+        commit(action, post)
+      end
+
+      def refund(amount, authorization, options={})
+        action = :refund
+        post = {}
+        add_credentials(post)
+        add_invoice(action, post, amount, options)
+        add_reference(post, authorization)
+        add_checksum(action, post)
+
+        commit(action, post)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(1000, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def verify_credentials
+        response = void("0", order_id: "0")
+        response.message.include? "Transaction not found"
+      end
+
+      def store(credit_card, options={})
+        action = :tokenize
+        post = {}
+        post[:partnerid] = options[:partner_id] if options[:partner_id]
+        post[:cardholderid] = options[:cardholder_id] if options[:cardholder_id]
+        add_credentials(post)
+        add_payment_method(post, credit_card, action, options)
+        add_customer_data(post, options)
+        add_checksum(action, post)
+
+        commit(action, post)
+      end
+
+      def invalidate(authorization, options={})
+        action = :invalidate
+        post = {}
+        post[:partnerid] = options[:partner_id] if options[:partner_id]
+        add_credentials(post)
+        post[:token] = authorization
+        add_checksum(action, post)
+
+        commit(action, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((cardnumber=)\d+), '\1[FILTERED]').
+          gsub(%r((cvv=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_credentials(post)
+        post[:toid] = @options[:merchant_id]
+        post[:totype] = 'Culqi'
+        post[:terminalid] = @options[:terminal_id]
+        post[:language] = 'ENG'
+      end
+
+      def add_invoice(action, post, money, options)
+        case action
+        when :capture
+          post[:captureamount] = amount(money)
+        when :refund
+          post[:refundamount] = amount(money)
+          post[:reason] = 'none'
+        else
+          post[:amount] = amount(money)
+        end
+
+        post[:description] = options[:order_id]
+        post[:redirecturl] = options[:redirect_url] || 'http://www.example.com'
+      end
+
+      def add_payment_method(post, payment_method, action, options)
+        if payment_method.is_a?(String)
+          post[:token] = payment_method
+          post[:cvv] = options[:cvv] if options[:cvv]
+        else
+          post[:cardnumber] = payment_method.number
+          post[:cvv] = payment_method.verification_value
+          post[:firstname], post[:lastname] = payment_method.name.split(' ')
+          if action == :tokenize
+            post[:expirymonth] = format(payment_method.month, :two_digits)
+            post[:expiryyear] = format(payment_method.year, :four_digits)
+          else
+            post[:expiry_month] = format(payment_method.month, :two_digits)
+            post[:expiry_year] = format(payment_method.year, :four_digits)
+          end
+        end
+      end
+
+      def add_customer_data(post, options)
+        post[:emailaddr] = options[:email] || 'unspecified@example.com'
+        if (billing_address = options[:billing_address] || options[:address])
+          post[:street] = [billing_address[:address1], billing_address[:address2]].join(' ')
+          post[:city] = billing_address[:city]
+          post[:state] = billing_address[:state]
+          post[:countrycode] = billing_address[:country]
+          post[:zip]    = billing_address[:zip]
+          post[:telno] = billing_address[:phone]
+          post[:telnocc] = options[:telephone_country_code] || '051'
+        end
+      end
+
+      def add_checksum(action, post)
+        checksum_elements = case action
+        when :capture;  [post[:toid], post[:trackingid], post[:captureamount], @options[:secret_key]]
+        when :void;     [post[:toid], post[:description], post[:trackingid], @options[:secret_key]]
+        when :refund;   [post[:toid], post[:trackingid], post[:refundamount], @options[:secret_key]]
+        when :tokenize; [post[:partnerid], post[:cardnumber], post[:cvv], @options[:secret_key]]
+        when :invalidate; [post[:partnerid], post[:token], @options[:secret_key]]
+        else [post[:toid], post[:totype], post[:amount], post[:description], post[:redirecturl],
+              post[:cardnumber] || post[:token], @options[:secret_key]]
+        end
+
+        post[:checksum] = Digest::MD5.hexdigest(checksum_elements.compact.join('|'))
+      end
+
+      def add_reference(post, authorization)
+        post[:trackingid] = authorization
+      end
+
+      ACTIONS = {
+        authorize: "SingleCallGenericServlet",
+        capture: "SingleCallGenericCaptureServlet",
+        void: "SingleCallGenericVoid",
+        refund: "SingleCallGenericReverse",
+        tokenize: "SingleCallTokenServlet",
+        invalidate: "SingleCallInvalidateToken",
+        tokenpay: "SingleCallTokenTransaction",
+      }
+
+      def commit(action, params)
+        response = begin
+          parse(ssl_post(url + ACTIONS[action], post_data(action, params), headers))
+        rescue ResponseError => e
+          parse(e.response.body)
+        end
+
+        success = success_from(response)
+
+        Response.new(
+          success,
+          message_from(response),
+          response,
+          authorization: success ? authorization_from(response) : nil,
+          cvv_result: success ? cvvresult_from(response) : nil,
+          error_code: success ? nil : error_from(response),
+          test: test?
+        )
+      end
+
+      def headers
+        {
+          "Accept"  => "application/json",
+          "Content-Type"  => "application/x-www-form-urlencoded;charset=UTF-8"
+        }
+      end
+
+      def post_data(action, params)
+        params.map {|k, v| "#{k}=#{CGI.escape(v.to_s)}"}.join('&')
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          message = "Invalid JSON response received from CulqiGateway. Please contact CulqiGateway if you continue to receive this message."
+          message += "(The raw response returned by the API was #{body.inspect})"
+          {
+            "status" => "N",
+            "statusdescription" => message
+          }
+        end
+      end
+
+      def success_from(response)
+        response['status'] == 'Y'
+      end
+
+      def message_from(response)
+        response['statusdescription'] || response['statusDescription']
+      end
+
+      def authorization_from(response)
+        response['trackingid'] || response['token']
+      end
+
+      def cvvresult_from(response)
+        CVVResult.new(response['cvvresult'])
+      end
+
+      def error_from(response)
+        response['resultcode']
+      end
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ module ActiveMerchant #:nodoc:
       XSD_VERSION = "1.121"
 
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
-      self.supported_countries = %w(US BR CA CN DK FI FR DE JP MX NO SE GB SG)
+      self.supported_countries = %w(US BR CA CN DK FI FR DE JP MX NO SE GB SG LB)
 
       self.default_currency = 'USD'
       self.currencies_without_fractions = %w(JPY)

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

@@ -274,6 +274,8 @@ module ActiveMerchant #:nodoc:
           message_from(response),
           response,
           authorization: authorization_from(action, response, amount),
+          avs_result: success_from(response) ? avs_from(response) : nil,
+          cvv_result: success_from(response) ? cvv_from(response) : nil,
           test: test?
         )
       end
@@ -294,6 +296,14 @@ module ActiveMerchant #:nodoc:
         response["expressresponsemessage"]
       end
 
+      def avs_from(response)
+        AVSResult.new(code: response["card"]["avsresponsecode"]) if response["card"]
+      end
+
+      def cvv_from(response)
+        CVVResult.new(response["card"]["cvvresponsecode"]) if response["card"]
+      end
+
       def split_authorization(authorization)
         authorization.split("|")
       end

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

@@ -226,9 +226,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_credit_card(xml, credit_card, options)
-
         if credit_card.respond_to?(:track_data) && credit_card.track_data.present?
           xml.tag! "Track1", credit_card.track_data
+          xml.tag! "Ecommerce_Flag", "R"
         else
           xml.tag! "Card_Number", credit_card.number
           xml.tag! "Expiry_Date", expdate(credit_card)

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

@@ -23,7 +23,7 @@ module ActiveMerchant #:nodoc:
       def purchase(money, payment, options={})
         MultiResponse.run do |r|
           r.process { authorize(money, payment, options) }
-          r.process { capture(money, r.authorization, options) }
+          r.process { capture(money, r.authorization, options) } unless capture_requested?(r)
         end
       end
 
@@ -290,6 +290,10 @@ EOS
       def nestable_hash
         Hash.new {|h,k| h[k] = Hash.new(&h.default_proc) }
       end
+
+      def capture_requested?(response)
+        response.params.try(:[], "payment").try(:[], "status") == "CAPTURE_REQUESTED"
+      end
     end
   end
 end

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

@@ -16,7 +16,7 @@ module ActiveMerchant #:nodoc:
       # However, regular accounts with DPS only support VISA and Mastercard
       self.supported_cardtypes = [ :visa, :master, :american_express, :diners_club, :jcb ]
 
-      self.supported_countries = %w[ AU CA DE ES FR GB HK IE MY NL NZ SG US ZA ]
+      self.supported_countries = %w[ AU FJ GB HK IE MY NZ PG SG US ]
 
       self.homepage_url = 'http://www.paymentexpress.com/'
       self.display_name = 'PaymentExpress'

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

@@ -103,6 +103,18 @@ module ActiveMerchant #:nodoc:
         commit_periodic(build_periodic_item(:remove_triggered, options[:amount], nil, options))
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<merchantID>).+(</merchantID>)), '\1[FILTERED]\2').
+          gsub(%r((<password>).+(</password>)), '\1[FILTERED]\2').
+          gsub(%r((<cardNumber>).+(</cardNumber>)), '\1[FILTERED]\2').
+          gsub(%r((<cvv>).+(</cvv>)), '\1[FILTERED]\2')
+      end
+
       private
 
       def build_purchase_request(money, credit_card, options)

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

@@ -380,7 +380,7 @@ module ActiveMerchant #:nodoc:
             card[:swipe_data] = creditcard.track_data
             card[:fallback_reason] = creditcard.fallback_reason if creditcard.fallback_reason
             card[:read_method] = "contactless" if creditcard.contactless_emv
-            post[:read_method] = "contactless_magstripe_mode" if creditcard.contactless_magstripe
+            card[:read_method] = "contactless_magstripe_mode" if creditcard.contactless_magstripe
           else
             card[:number] = creditcard.number
             card[:exp_month] = creditcard.month

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

@@ -5,7 +5,7 @@ module ActiveMerchant
     class VancoGateway < Gateway
       include Empty
 
-      self.test_url = 'https://www.vancodev.com/cgi-bin/wstest2.vps'
+      self.test_url = 'https://uat.vancopayments.com/cgi-bin/ws2.vps'
       self.live_url = 'https://myvanco.vancopayments.com/cgi-bin/ws2.vps'
 
       self.supported_countries = ['US']

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

@@ -10,6 +10,8 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'USD'
       self.display_name = 'WePay'
 
+      API_VERSION = "2016-12-07"
+
       def initialize(options = {})
         requires!(options, :client_id, :account_id, :access_token)
         super(options)
@@ -18,38 +20,47 @@ module ActiveMerchant #:nodoc:
       def purchase(money, payment_method, options = {})
         post = {}
         if payment_method.is_a?(String)
-          purchase_with_token(post, money, payment_method, options)
+          MultiResponse.run do |r|
+            r.process { authorize_with_token(post, money, payment_method, options) }
+            r.process { capture(money, r.authorization, options) }
+          end
         else
           MultiResponse.run do |r|
             r.process { store(payment_method, options) }
-            r.process { purchase_with_token(post, money, split_authorization(r.authorization).first, options) }
+            r.process { authorize_with_token(post, money, r.authorization, options) }
+            r.process { capture(money, r.authorization, options) }
           end
         end
       end
 
       def authorize(money, payment_method, options = {})
-        post = {auto_capture: 0}
+        post = {}
         if payment_method.is_a?(String)
-          purchase_with_token(post, money, payment_method, options)
+          authorize_with_token(post, money, payment_method, options)
         else
           MultiResponse.run do |r|
             r.process { store(payment_method, options) }
-            r.process { purchase_with_token(post, money, split_authorization(r.authorization).first, options) }
+            r.process { authorize_with_token(post, money, r.authorization, options) }
           end
         end
       end
 
       def capture(money, identifier, options = {})
+        checkout_id, original_amount = split_authorization(identifier)
+
         post = {}
-        post[:checkout_id] = split_authorization(identifier).first
-        commit('/checkout/capture', post)
+        post[:checkout_id] = checkout_id
+        if(money && (original_amount != amount(money)))
+          post[:amount] = amount(money)
+        end
+        commit('/checkout/capture', post, options)
       end
 
       def void(identifier, options = {})
         post = {}
         post[:checkout_id] = split_authorization(identifier).first
         post[:cancel_reason] = (options[:description] || "Void")
-        commit('/checkout/cancel', post)
+        commit('/checkout/cancel', post, options)
       end
 
       def refund(money, identifier, options = {})
@@ -61,10 +72,9 @@ module ActiveMerchant #:nodoc:
           post[:amount] = amount(money)
         end
         post[:refund_reason] = (options[:description] || "Refund")
-        post[:app_fee] = options[:application_fee] if options[:application_fee]
         post[:payer_email_message] = options[:payer_email_message] if options[:payer_email_message]
         post[:payee_email_message] = options[:payee_email_message] if options[:payee_email_message]
-        commit("/checkout/refund", post)
+        commit("/checkout/refund", post, options)
       end
 
       def store(creditcard, options = {})
@@ -76,53 +86,46 @@ module ActiveMerchant #:nodoc:
         post[:email] = options[:email] || "unspecified@example.com"
         post[:cc_number] = creditcard.number
         post[:cvv] = creditcard.verification_value unless options[:recurring]
-        post[:expiration_month] = "#{creditcard.month}"
-        post[:expiration_year] = "#{creditcard.year}"
+        post[:expiration_month] = creditcard.month
+        post[:expiration_year] = creditcard.year
         post[:original_ip] = options[:ip] if options[:ip]
         post[:original_device] = options[:device_fingerprint] if options[:device_fingerprint]
+
         if(billing_address = (options[:billing_address] || options[:address]))
-          post[:address] = {
-            "address1" => billing_address[:address1],
-            "city"     => billing_address[:city],
-            "country"  => billing_address[:country]
-          }
-          if(post[:country] == "US")
-            post[:address]["zip"] = billing_address[:zip]
-            post[:address]["state"] = billing_address[:state]
-          else
-            post[:address]["region"] = billing_address[:state]
-            post[:address]["postcode"] = billing_address[:zip]
-          end
+          post[:address] = {}
+          post[:address]["address1"] = billing_address[:address1] if billing_address[:address1]
+          post[:address]["city"]     = billing_address[:city] if billing_address[:city]
+          post[:address]["country"]  = billing_address[:country]  if billing_address[:country]
+          post[:address]["region"]   = billing_address[:state]  if billing_address[:state]
+          post[:address]["postal_code"] = billing_address[:zip]
         end
 
         if options[:recurring] == true
           post[:client_secret] = @options[:client_secret]
-          commit('/credit_card/transfer', post)
+          commit('/credit_card/transfer', post, options)
         else
-          commit('/credit_card/create', post)
+          commit('/credit_card/create', post, options)
         end
       end
 
       private
 
-      def purchase_with_token(post, money, token, options)
+      def authorize_with_token(post, money, token, options)
         add_token(post, token)
         add_product_data(post, money, options)
-        commit('/checkout/create', post)
+        commit('/checkout/create', post, options)
       end
 
       def add_product_data(post, money, options)
         post[:account_id] = @options[:account_id]
         post[:amount] = amount(money)
         post[:short_description] = (options[:description] || "Purchase")
-        post[:type] = (options[:type] || "GOODS")
+        post[:type] = (options[:type] || "goods")
         post[:currency] = (options[:currency] || currency(money))
         post[:long_description] = options[:long_description] if options[:long_description]
         post[:payer_email_message] = options[:payer_email_message] if options[:payer_email_message]
         post[:payee_email_message] = options[:payee_email_message] if options[:payee_email_message]
         post[:reference_id] = options[:order_id] if options[:order_id]
-        post[:app_fee] = options[:application_fee] if options[:application_fee]
-        post[:fee_payer] = options[:fee_payer] if options[:fee_payer]
         post[:redirect_uri] = options[:redirect_uri] if options[:redirect_uri]
         post[:callback_uri] = options[:callback_uri] if options[:callback_uri]
         post[:fallback_uri] = options[:fallback_uri] if options[:fallback_uri]
@@ -133,11 +136,26 @@ module ActiveMerchant #:nodoc:
         post[:preapproval_id] = options[:preapproval_id] if options[:preapproval_id]
         post[:prefill_info] = options[:prefill_info] if options[:prefill_info]
         post[:funding_sources] = options[:funding_sources] if options[:funding_sources]
+        add_fee(post, options)
       end
 
       def add_token(post, token)
-        post[:payment_method_id]   = token
-        post[:payment_method_type] = "credit_card"
+        payment_method = {}
+        payment_method[:type] = "credit_card"
+        payment_method[:credit_card] = {
+          id: token,
+          auto_capture: false
+        }
+
+        post[:payment_method] = payment_method
+      end
+
+      def add_fee(post, options)
+        if options[:application_fee] || options[:fee_payer]
+          post[:fee] = {}
+          post[:fee][:app_fee] = options[:application_fee] if options[:application_fee]
+          post[:fee][:fee_payer] = options[:fee_payer] if options[:fee_payer]
+        end
       end
 
       def parse(response)
@@ -149,7 +167,7 @@ module ActiveMerchant #:nodoc:
           response = parse(ssl_post(
             ((test? ? test_url : live_url) + action),
             params.to_json,
-            headers
+            headers(options)
           ))
         rescue ResponseError => e
           response = parse(e.response.body)
@@ -178,7 +196,8 @@ module ActiveMerchant #:nodoc:
       def authorization_from(response, params)
         return response["credit_card_id"].to_s if response["credit_card_id"]
 
-        [response["checkout_id"], params[:amount]].join('|')
+        original_amount = response["amount"].nil? ? nil : sprintf("%0.02f", response["amount"])
+        [response["checkout_id"], original_amount].join('|')
       end
 
       def split_authorization(authorization)
@@ -192,14 +211,18 @@ module ActiveMerchant #:nodoc:
         return Response.new(false, message)
       end
 
-      def headers
+      def headers(options)
         {
           "Content-Type"  => "application/json",
           "User-Agent"    => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
-          "Authorization" => "Bearer #{@options[:access_token]}"
+          "Authorization" => "Bearer #{@options[:access_token]}",
+          "Api-Version"   => api_version(options)
         }
       end
+
+      def api_version(options)
+        options[:version] || API_VERSION
+      end
     end
   end
 end
-

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

@@ -239,6 +239,7 @@ module ActiveMerchant #:nodoc:
             when :reversal
               xml.tag! 'GuWID', options[:preauthorization]
             end
+            add_customer_data(xml, options)
           end
         end
       end

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

@@ -223,8 +223,11 @@ module ActiveMerchant #:nodoc:
 
               add_address(xml, (options[:billing_address] || options[:address]))
             end
-            if options[:ip]
-              xml.tag! 'session', 'shopperIPAddress' => options[:ip]
+            if options[:ip] && options[:session_id]
+              xml.tag! 'session', 'shopperIPAddress' => options[:ip], 'id' => options[:session_id]
+            else
+              xml.tag! 'session', 'shopperIPAddress' => options[:ip] if options[:ip]
+              xml.tag! 'session', 'id' => options[:session_id] if options[:session_id]
             end
           end
         end
@@ -238,6 +241,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_address(xml, address)
+        return unless address
+
         address = address_with_defaults(address)
 
         xml.tag! 'cardAddress' do

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = "1.62.0"
+  VERSION = "1.63.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.62.0
+  version: 1.63.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-05 00:00:00.000000000 Z
+date: 2017-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -202,6 +202,7 @@ files:
 - lib/active_merchant/billing/gateways/conekta.rb
 - lib/active_merchant/billing/gateways/creditcall.rb
 - lib/active_merchant/billing/gateways/credorax.rb
+- lib/active_merchant/billing/gateways/culqi.rb
 - lib/active_merchant/billing/gateways/cyber_source.rb
 - lib/active_merchant/billing/gateways/data_cash.rb
 - lib/active_merchant/billing/gateways/dibs.rb
@@ -395,7 +396,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="