activemerchant 1.60.0 → 1.61.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d43ab38ffa5badee3266ac1da82758f7f5a928d
-  data.tar.gz: 044674b27950c204a881c24ef8556e4d01841f22
+  metadata.gz: 1fe35e2a54670d5e8b4a1b03b60e0fbdb63b862e
+  data.tar.gz: 776d6fcde383b0ca43232791f8816ea573a21b3a
 SHA512:
-  metadata.gz: 304da6ed75b96dbfa07fb1546f318a224a021c46d2d528b29db4d821858838c28ea4b3ecc9b7319d739281224a6e42c7a5880bd7f06483165f92d8b99f544d80
-  data.tar.gz: 889d972567c2b9cb383b29f8c472e27047b6e5b229e512b85478d9b60759014968c23963c1b48fe3b2aa1db7c36c9323e5fe5011cc00e4e3173db0c397e13f5f
+  metadata.gz: 1c4e2de0b7a0302afbbab9c6a486db123ac8228f83d3f7ea844ccd2108d80a79234627f2a9ce5824a9782c5eff560ef644aefea40d729564e97afb30d476946b
+  data.tar.gz: 2d259ac6111733da3f2d093f8638a5f2adcd8eb47a3adcce29197e37c4605daca606a2214ed274629872bdd5d6ba931acec991abfa1c398758941542d1b03963

data/CHANGELOG

@@ -1,5 +1,69 @@
 = ActiveMerchant CHANGELOG
 
+== Version 1.61.0 (November 7, 2016)
+* Add codes AQ, BQ, SX, and SS to list of countries and update SD numeric code [zxlin]
+* AuthorizeNet: Update supported countries list [shasum]
+* Barclay SmartPay: Add support for credit [shasum]
+* Barclaycard SmartPay: Update supported countries [shasum]
+* BluePay: Add Canada to supported countries list [shasum]
+* BlueSnap: Update countries list [shasum]
+* Braintree Blue: Add Android Pay support [mrezentes]
+* Braintree Blue: Add remote test to verify card token [shasum]
+* Braintree Blue: Get Android Pay tx id from payment method, not options [mrezentes]
+* CardStream: Add MXN currency code [curiousepic]
+* CardStream: Set captureDelay to zero on purchase [davidsantoso]
+* CitrusPay: Add gateway [duff]
+* CitrusPay: Update URL to current API version [davidsantoso]
+* Clearhaus: Fix refund of captures [duff]
+* Clearhaus: Update list of non fractal currencies [curiousepic]
+* Clearhaus: Use localized amount [curiouspic]
+* Conekta: Add void action [MauricioMurga]
+* Credorax: Add gateway support [davidsantoso]
+* CyberSource, Paymill, Payflow: Add verify_credentials [duff]
+* CyberSource: Combine auth_reversal with Void [curiousepic]
+* CyberSource: Increase merchant defined data fields [davidsantoso]
+* CyberSource: Look up alpha2 country code [curiousepic]
+* CyberSource: Use localized_amount [curiousepic]
+* Element: Pass order_id and shipping address [curiousepic]
+* Fat Zebra: Add cavv, xid, and sli fields [curiousepic]
+* Fat Zebra: Fix improper descriptor nesting [curiousepic]
+* Find countries if they are differently cased [curiousepic]
+* GlobalCollect: Update credit card brand list [curiousepic]
+* Jetpay: Support endpoint for Canada [shasum]
+* Linkpoint: Clean whitespace from PEM [curiousepic]
+* Litle: Retain amount to send in auth reversals [curiousepic]
+* Litle: add scrubbing support [bruno]
+* MONEI: Update supported countries list [davidgf]
+* MiGS: Handle IDR currency [curiousepic]
+* Migs: Add support for void [mohsenottello]
+* Migs: Support some additional fields [duff]
+* Moneris: Fix unit test stubs [shasum]
+* Moneris: add scrubbing support [bruno]
+* NMI, FirstData: Support verify_credentials [curiousepic]
+* Openpay: Add support for verify [duff]
+* PayJunctionV2: Add gateway support [shasum]
+* PayU Latam: Add new gateway [shasum]
+* PayU Latam: Update supported countries list [shasum]
+* Payflow: Update supported countries list [shasum]
+* PaypalExpress: Add SoftDescriptor field [talyssonoc]
+* Redsys: Added DOP and CRC currency [davidsantoso]
+* Sage: Add support for scrubbing [bruno]
+* SagePay: Fix truncation [duff]
+* SecurionPay: Update supported countries list [shasum]
+* Stripe: Increase authorize amount during verify [davidsantoso]
+* Stripe: Set minimum authorize amount depending on currency [davidsantoso]
+* Stripe: Support new network tokenization API params [methodmissing]
+* Stripe: Update supported countries list [shasum]
+* TNS and CitrusPay: Support scrub and verify_credentials [duff]
+* TNS and CitrusPay: Update to version 36 of the API [duff]
+* TNS: Try TLS v1 [duff]
+* Telr: Add gateway support [curiousepic]
+* TransFirsTransactionExpress: Remove blank cvv element [davidsantoso]
+* TransFirsTransactionExpress: Take into account blank string CVV [davidsantoso]
+* Vanco: Improve handling of success determination [duff]
+* Worldpay: Add hcgAdditionalData element [davidsantoso]
+* Worldpay: Report error code [curiousepic]
+
 == Version 1.60.0 (July 4, 2016)
 * Orbital: Fix CC num leak on profile calls [drewblas]
 * VisaNetPeru: Add ability to refund [duff]

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

@@ -8,7 +8,7 @@ module ActiveMerchant
       self.test_url = 'https://apitest.authorize.net/xml/v1/request.api'
       self.live_url = 'https://api2.authorize.net/xml/v1/request.api'
 
-      self.supported_countries = %w(AD AT AU BE BG CA CH CY CZ DE DK EE ES FI FR GB GB GI GR HU IE IS IT LI LT LU LV MC MT NL NO PL PT RO SE SI SK SM TR US VA)
+      self.supported_countries = %w(AD AT AU BE BG CA CH CY CZ DE DK EE ES FI FR GB GB GI GR HU IE IL IS IT LI LT LU LV MC MT NL NO PL PT RO SE SI SK SM TR US VA)
       self.default_currency = 'USD'
       self.money_format = :dollars
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :maestro]

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

@@ -4,7 +4,7 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://pal-test.barclaycardsmartpay.com/pal/servlet'
       self.live_url = 'https://pal-live.barclaycardsmartpay.com/pal/servlet'
 
-      self.supported_countries = ['AR', 'AT', 'BE', 'BR', 'CA', 'CH', 'CL', 'CN', 'CO', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GB', 'HK', 'ID', 'IE', 'IL', 'IN', 'IT', 'JP', 'KR', 'LU', 'MX', 'MY', 'NL', 'NO', 'PA', 'PE', 'PH', 'PL', 'PT', 'RU', 'SE', 'SG', 'TH', 'TR', 'TW', 'US', 'VN', 'ZA']
+      self.supported_countries = ['AL', 'AD', 'AM', 'AT', 'AZ', 'BY', 'BE', 'BA', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR', 'GE', 'DE', 'GR', 'HU', 'IS', 'IE', 'IT', 'KZ', 'LV', 'LI', 'LT', 'LU', 'MK', 'MT', 'MD', 'MC', 'ME', 'NL', 'NO', 'PL', 'PT', 'RO', 'RU', 'SM', 'RS', 'SK', 'SI', 'ES', 'SE', 'CH', 'TR', 'UA', 'GB', 'VA']
       self.default_currency = 'EUR'
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :dankort, :maestro]
@@ -62,6 +62,14 @@ module ActiveMerchant #:nodoc:
         commit('refund', post)
       end
 
+      def credit(money, creditcard, options = {})
+        post = payment_request(money, options)
+        post[:amount] = amount_hash(money, options[:currency])
+        post[:card] = credit_card_hash(creditcard)
+
+        commit('refundWithData', post)
+      end
+
       def void(identification, options = {})
         requires!(options, :order_id)
 
@@ -137,6 +145,8 @@ module ActiveMerchant #:nodoc:
         case e.response.code
         when '401'
           return Response.new(false, 'Invalid credentials', {}, :test => test?)
+        when '403'
+          return Response.new(false, 'Not allowed', {}, :test => test?)
         when '422'
           return Response.new(false, 'Unprocessable Entity', {}, :test => test?)
         when '500'
@@ -198,6 +208,7 @@ module ActiveMerchant #:nodoc:
       def success_from(response)
         return true if response.has_key?('authCode')
         return true if response['result'] == 'Success'
+        return true if response['resultCode'] == 'Received'
         successful_responses = %w([capture-received] [cancel-received] [refund-received])
         successful_responses.include?(response['response'])
       end

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

@@ -43,7 +43,7 @@ module ActiveMerchant #:nodoc:
         'USUAL_DATE' => :undoc_usual_date, # Not found in the bp20rebadmin API doc.
       }
 
-      self.supported_countries = ['US']
+      self.supported_countries = ['US', 'CA']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
       self.homepage_url        = 'http://www.bluepay.com/'
       self.display_name        = 'BluePay'

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

@@ -5,7 +5,7 @@ module ActiveMerchant
     class BlueSnapGateway < Gateway
       self.test_url = "https://sandbox.bluesnap.com/services/2"
       self.live_url = "https://ws.bluesnap.com/services/2"
-      self.supported_countries = %w(US GB)
+      self.supported_countries = %w(US CA GB AT BE BG HR CY CZ DK EE FI FR DE GR HU IE IT LV LT LU MT NL PL PT RO SK SI ES SE)
 
       self.default_currency = 'USD'
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club, :maestro]

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

@@ -576,6 +576,14 @@ module ActiveMerchant #:nodoc:
                 :cardholder_name => "#{credit_card_or_vault_id.first_name} #{credit_card_or_vault_id.last_name}",
                 :cryptogram => credit_card_or_vault_id.payment_cryptogram
               }
+          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
+              }
             end
           else
             parameters[:credit_card] = {

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

@@ -25,6 +25,7 @@ module ActiveMerchant #:nodoc:
         "HKD" => "344",
         "ICK" => "352",
         "JPY" => "392",
+        "MXN" => "484",
         "NOK" => "578",
         "NZD" => "554",
         "SEK" => "752",
@@ -87,6 +88,7 @@ module ActiveMerchant #:nodoc:
 
       def purchase(money, credit_card_or_reference, options = {})
         post = {}
+        add_pair(post, :captureDelay, 0)
         add_amount(post, money, options)
         add_invoice(post, credit_card_or_reference, money, options)
         add_credit_card_or_reference(post, credit_card_or_reference)

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

@@ -0,0 +1,24 @@
+module ActiveMerchant
+  module Billing
+    class CitrusPayGateway < Gateway
+      include MastercardGateway
+
+      class_attribute :live_na_url, :live_ap_url, :test_na_url, :test_ap_url
+
+      self.test_na_url = 'https://test-gateway.mastercard.com/api/rest/version/39/'
+      self.test_ap_url = 'https://test-gateway.mastercard.com/api/rest/version/39/'
+
+      self.live_na_url = 'https://na-gateway.mastercard.com/api/rest/version/39/'
+      self.live_ap_url = 'https://ap-gateway.mastercard.com/api/rest/version/39/'
+
+      self.display_name = 'Citrus Pay'
+      self.homepage_url = 'http://www.citruspay.com/'
+      self.supported_countries = %w(AR AU BR FR DE HK MX NZ SG GB US)
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :maestro, :laser]
+      self.ssl_version = :TLSv1
+
+    end
+  end
+end
+

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

@@ -10,6 +10,7 @@ module ActiveMerchant #:nodoc:
                                   'HU', 'IS', 'IE', 'IT', 'LV', 'LI', 'LT', 'LU', 'MT', 'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'GB']
 
       self.default_currency    = 'EUR'
+      self.currencies_without_fractions = %w(BIF BYR DJF GNF JPY KMF KRW PYG RWF VND VUV XAF XOF XPF)
       self.supported_cardtypes = [:visa, :master]
 
       self.homepage_url = 'https://www.clearhaus.com'
@@ -121,7 +122,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_amount(post, amount, options)
-        post[:amount]   = amount(amount)
+        post[:amount]   = localized_amount(amount, options[:currency] || default_currency)
         post[:currency] = (options[:currency] || default_currency)
       end
 
@@ -173,7 +174,7 @@ module ActiveMerchant #:nodoc:
           success_from(response),
           message_from(response),
           response,
-          authorization: authorization_from(response),
+          authorization: authorization_from(action, response),
           test: test?,
           error_code: error_code_from(response)
         )
@@ -193,8 +194,15 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def authorization_from(response)
-        response['id']
+      def authorization_from(action, response)
+        id_of_auth_for_capture(action) || response['id']
+      end
+
+      def id_of_auth_for_capture(action)
+        match = action.match(/authorizations\/(.+)\/captures/)
+        return nil unless match
+
+        match.captures.first
       end
 
       def generate_signature(body)

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

@@ -12,7 +12,7 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :key)
-        options[:version] ||= '0.3.0'
+        options[:version] ||= '1.0.0'
         super
       end
 
@@ -55,6 +55,11 @@ module ActiveMerchant #:nodoc:
         commit(:post, "charges/#{identifier}/refund", post)
       end
 
+      def void(identifier, options = {})
+        post = {}
+        commit(:post, "charges/#{identifier}/void", post)
+      end
+
       def supports_scrubbing
         true
       end

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

@@ -0,0 +1,234 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CredoraxGateway < Gateway
+      class_attribute :test_url, :live_na_url, :live_eu_url
+
+      self.display_name = "Credorax Gateway"
+      self.homepage_url = "https://www.credorax.com/"
+
+      self.test_url = "https://intconsole.credorax.com/intenv/service/gateway"
+
+      # The live URL is assigned on a per merchant basis once certification has passed
+      # See the Credorax remote tests for the full certification test suite
+      #
+      # Once you have your assigned subdomain, you can override the live URL in your application via:
+      # ActiveMerchant::Billing::CredoraxGateway.live_url = "https://assigned-subdomain.credorax.net/crax_gate/service/gateway"
+      self.live_url = 'https://assigned-subdomain.credorax.net/crax_gate/service/gateway'
+
+      self.supported_countries = %w(DE GB FR IT ES PL NL BE GR CZ PT SE HU RS AT CH BG DK FI SK NO IE HR BA AL LT MK SI LV EE ME LU MT IS AD MC LI SM)
+      self.default_currency = "EUR"
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :maestro]
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :cipher_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+        add_email(post, options)
+        add_echo(post, options)
+
+        commit(:purchase, post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+        add_email(post, options)
+        add_echo(post, options)
+
+        commit(:authorize, post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+        add_echo(post, options)
+
+        commit(:capture, post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_customer_data(post, options)
+        reference_action = add_reference(post, authorization)
+        add_echo(post, options)
+        post[:a1] = options[:order_id] || generate_unique_id
+
+        commit(:void, post, reference_action)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+        add_echo(post, options)
+
+        commit(:refund, post)
+      end
+
+      def credit(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+        add_email(post, options)
+        add_echo(post, options)
+
+        commit(:credit, post)
+      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 supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((b1=)\d+), '\1[FILTERED]').
+          gsub(%r((b5=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_invoice(post, money, options)
+        post[:a4] = amount(money)
+        post[:a1] = options[:order_id] || generate_unique_id
+        post[:a5] = options[:currency] || currency(money)
+      end
+
+      CARD_TYPES = {
+        "visa" => '1',
+        "mastercard" => '2',
+        "maestro" => '9'
+      }
+
+      def add_payment_method(post, payment_method)
+        post[:c1] = payment_method.name
+        post[:b2] = CARD_TYPES[payment_method.brand] || ''
+        post[:b1] = payment_method.number
+        post[:b5] = payment_method.verification_value
+        post[:b4] = format(payment_method.year, :two_digits)
+        post[:b3] = format(payment_method.month, :two_digits)
+      end
+
+      def add_customer_data(post, options)
+        post[:d1] = options[:ip] || '127.0.0.1'
+        if (billing_address = options[:billing_address])
+          # Credorax has separate fields for street number and street name
+          post[:c4] = billing_address[:address1].split.first
+          post[:c5] = billing_address[:address1].split.drop(1).join(" ")
+          post[:c7] = billing_address[:city]
+          post[:c10] = billing_address[:zip]
+          post[:c8] = billing_address[:state]
+          post[:c9] = billing_address[:country]
+          post[:c2] = billing_address[:phone]
+        end
+      end
+
+      def add_reference(post, authorization)
+        response_id, authorization_code, request_id, action = authorization.split(";")
+        post[:g2] = response_id
+        post[:g3] = authorization_code
+        post[:g4] = request_id
+        action || :authorize
+      end
+
+      def add_email(post, options)
+        post[:c3] = options[:email] || 'unspecified@example.com'
+      end
+
+      def add_echo(post, options)
+        # The d2 parameter is used during the certification process
+        # See remote tests for full certification test suite
+        post[:d2] = options[:echo] unless options[:echo].blank?
+      end
+
+      ACTIONS = {
+        purchase: '1',
+        authorize: '2',
+        capture: '3',
+        authorize_void:'4',
+        refund: '5',
+        credit: '6',
+        purchase_void: '7',
+        refund_void: '8',
+        capture_void: '9'
+      }
+
+      def commit(action, params, reference_action = nil)
+        raw_response = ssl_post(url, post_data(action, params, reference_action))
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: "#{response["Z1"]};#{response["Z4"]};#{response["A1"]};#{action}",
+          avs_result: AVSResult.new(code: response["Z9"]),
+          cvv_result: CVVResult.new(response["Z14"]),
+          test: test?
+        )
+      end
+
+      def sign_request(params)
+        params = params.sort
+        params.each { |param| param[1].gsub!(/[<>()\\]/, ' ') }
+        values = params.map { |param| param[1].strip }
+        Digest::MD5.hexdigest(values.join + @options[:cipher_key])
+      end
+
+      def post_data(action, params, reference_action)
+        params.keys.each { |key| params[key] = params[key].to_s}
+        params[:M] = @options[:merchant_id]
+        params[:O] = request_action(action, reference_action)
+        params[:K] = sign_request(params)
+        params.map {|k, v| "#{k}=#{CGI.escape(v.to_s)}"}.join('&')
+      end
+
+      def request_action(action, reference_action)
+        if reference_action
+          ACTIONS["#{reference_action}_#{action}".to_sym]
+        else
+          ACTIONS[action]
+        end
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        Hash[CGI::parse(body).map{|k,v| [k.upcase,v.first]}]
+      end
+
+      def success_from(response)
+        response["Z2"] == "0"
+      end
+
+      def message_from(response)
+        if success_from(response)
+          "Succeeded"
+        else
+          response["Z3"] || "Unable to read error message"
+        end
+      end
+    end
+  end
+end