activemerchant 1.56.0 → 1.57.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a7fa5a42dbb05e1c335a93e8cefc85781e7cbae
-  data.tar.gz: 928d0561eab8bc6a0fcac4245ccc2342d4e8fa6a
+  metadata.gz: 763b8ca398277831841d2b263a482a46e2f8793b
+  data.tar.gz: 6acb014413ea74d8b36ebe9a2a40ae04e60de312
 SHA512:
-  metadata.gz: bf1511639e9a72d13e6be69a301e0f0553cd4b52e65205a0e9f777c951e355124c16440182716a622beb5cd56037d98aea1659e1bdf49541b20d0438d2bf3802
-  data.tar.gz: 83dd4208bb147e5dce68f4751ff27e7298f03fffa0ef8c32f0f335fbf8fa79b1c4177d4839b236510fc7d9f66bedf98a4237085fbb2dcc94a9509d57f3004feb
+  metadata.gz: fce7249de3a503a61123f020bf72a374d5fe3fc9368c786e939135995ff5f4d5a392f31026325d7844ffd6458bc832d7c845e56d1f892c21b4e567ce322b5ec7
+  data.tar.gz: 204553110484e103828c9767405bf11cd704810a5689f1150bace201316445168ce9f523ba67278f9e3ff2010906ca2237cd8a6d58ddd99192671cffd08d36d3

data/CHANGELOG

@@ -1,5 +1,44 @@
 = ActiveMerchant CHANGELOG
 
+== Version 1.57.0 (February 1, 2016)
+* AuthorizeNetCim: Add unmaskExpirationDate option [RamilGilmanov]
+* Element: Add gateway support [davidsantoso]
+* Cardstream: 3D-secure capture fix [duff]
+* Auth.net: Update store to create payment profiles [davidsantoso]
+* CyberSource: Add support for mdd_fields [duff]
+* Worldpay: Add support for verify [davidsantoso]
+* Element: Add guard clause to handle undocumented errors [davidsantoso]
+* Clearhaus: Add tests for signed requests [anellis]
+* Stripe: Support adding cards to account [anellis]
+* Clearhaus: Add text_on_statement option [anellis]
+* Payeezy: Void and verify support [davidsantoso]
+* Creditcall: Use ecommerce rather than cnp [duff]
+* Payeezy: Add support for echecks [davidsantoso]
+* Bridgepay: Add ability to store cards and pay with token [anellis]
+* Initial support for Android Pay network tokenization cards [mrezentes]
+* Transfirst: Fix exception when not all eCheck information is present [davidsantoso]
+* Auth.net: Add tests for echeck refunds [davidsantoso]
+* Transfirst: use default values for some eCheck data [davidsantoso]
+* Element: Update the live URL endpoint [davidsantoso]
+* Element: Parse responses from unexpected API errors [davidsantoso]
+* Transfirst: Remove unused fields for echeck [davidsantoso]
+* Sage: Internal refactoring into a single gateway class w/ common http conn [anellis]
+* Cardstream: Adjust authorize and capture transactions [anellis]
+* NCRSecurePay: New gateway support (Monetra white-label) [rwdaigle]
+* Element: Map ReferenceNumber to order_id [duff]
+* Element: Use a better MotoECICode default [duff]
+* BraintreeBlue: Return transaction id for failed transactions when available [prburke]
+* PayPal: Add InContextPaypalExpressGateway [xuorig]
+* TransFirst: CVV is a required tag [duff]
+* Checkout V2: Add Descriptor Name and City Options [anellis]
+* Forte: Pass order_id [anellis]
+* Merchant ESolutioins: Truncate order_id [anellis]
+* Transfirst Transaction Express: New gateway support [sdball]
+* Stripe: Add `stripe_account` header option [anellis]
+* Cardstream: Add AVS code and message [anellis]
+* Barclaycard Smartpay: New gateway support [curiousepic]
+
+
 == Version 1.56.0 (December 1, 2015)
 * Add Cardknox gateway [dlehren]
 * Mercury: Add support for card present track 2 [ryanbalsdon]
@@ -201,6 +240,9 @@
 * Paystation: No longer require order_id everywhere [duff]
 * Checkout: Support descriptor_name and descriptor_city [duff]
 * Add supports_network_tokenization? to gateways [jnormore]
+* Bpoint: Handle message for invalid login [anellis]
+* TransFirst: Add scrubbing [davidsantoso]
+* TransFirst: Add back a few request fields [davidsantoso]
 
 
 == Version 1.50.0 (June 1, 2015)

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

@@ -8,7 +8,7 @@ module ActiveMerchant #:nodoc:
       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 ES FI FR GB GB GI GR HU IE IT LI LU 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 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]
@@ -154,25 +154,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def store(credit_card, options = {})
-        commit(:cim_store) do |xml|
-          xml.profile do
-            xml.merchantCustomerId(truncate(options[:merchant_customer_id], 20) || SecureRandom.hex(10))
-            xml.description(truncate(options[:description], 255)) unless empty?(options[:description])
-            xml.email(options[:email]) unless empty?(options[:email])
-
-            xml.paymentProfiles do
-              xml.customerType("individual")
-              add_billing_address(xml, credit_card, options)
-              add_shipping_address(xml, options, "shipToList")
-              xml.payment do
-                xml.creditCard do
-                  xml.cardNumber(truncate(credit_card.number, 16))
-                  xml.expirationDate(format(credit_card.year, :four_digits) + '-' + format(credit_card.month, :two_digits))
-                  xml.cardCode(credit_card.verification_value) if credit_card.verification_value
-                end
-              end
-            end
-          end
+        if options[:customer_profile_id]
+          create_customer_payment_profile(credit_card, options)
+        else
+          create_customer_profile(credit_card, options)
         end
       end
 
@@ -460,7 +445,6 @@ module ActiveMerchant #:nodoc:
             xml.routingNumber(check.routing_number)
             xml.accountNumber(check.account_number)
             xml.nameOnAccount(check.name)
-            xml.echeckType("WEB")
             xml.bankName(check.bank_name)
             xml.checkNumber(check.number)
           end
@@ -538,6 +522,46 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def create_customer_payment_profile(credit_card, options)
+        commit(:cim_store_update) do |xml|
+          xml.customerProfileId options[:customer_profile_id]
+          xml.paymentProfile do
+            add_billing_address(xml, credit_card, options)
+            xml.payment do
+              xml.creditCard do
+                xml.cardNumber(truncate(credit_card.number, 16))
+                xml.expirationDate(format(credit_card.year, :four_digits) + '-' + format(credit_card.month, :two_digits))
+                xml.cardCode(credit_card.verification_value) if credit_card.verification_value
+              end
+            end
+          end
+        end
+      end
+
+      def create_customer_profile(credit_card, options)
+        commit(:cim_store) do |xml|
+          xml.profile do
+            xml.merchantCustomerId(truncate(options[:merchant_customer_id], 20) || SecureRandom.hex(10))
+            xml.description(truncate(options[:description], 255)) unless empty?(options[:description])
+            xml.email(options[:email]) unless empty?(options[:email])
+
+            xml.paymentProfiles do
+              xml.customerType("individual")
+              add_billing_address(xml, credit_card, options)
+              add_shipping_address(xml, options, "shipToList")
+              xml.payment do
+                xml.creditCard do
+                  xml.cardNumber(truncate(credit_card.number, 16))
+                  xml.expirationDate(format(credit_card.year, :four_digits) + '-' + format(credit_card.month, :two_digits))
+                  xml.cardCode(credit_card.verification_value) if credit_card.verification_value
+                end
+              end
+            end
+          end
+        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])
@@ -602,6 +626,8 @@ module ActiveMerchant #:nodoc:
       def root_for(action)
         if action == :cim_store
           "createCustomerProfileRequest"
+        elsif action == :cim_store_update
+          "createCustomerPaymentProfileRequest"
         elsif is_cim_action?(action)
           "createCustomerProfileTransactionRequest"
         else
@@ -697,6 +723,11 @@ module ActiveMerchant #:nodoc:
           (empty?(element.content) ? nil : element.content)
         end
 
+        response[:customer_payment_profile_id] = if(element = doc.at_xpath("//customerPaymentProfileIdList/numericString") ||
+                                                              doc.at_xpath("//customerPaymentProfileId"))
+          (empty?(element.content) ? nil : element.content)
+        end
+
         response[:direct_response] = if(element = doc.at_xpath("//directResponse"))
           (empty?(element.content) ? nil : element.content)
         end

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

@@ -574,6 +574,7 @@ module ActiveMerchant #:nodoc:
       def build_get_customer_payment_profile_request(xml, options)
         xml.tag!('customerProfileId', options[:customer_profile_id])
         xml.tag!('customerPaymentProfileId', options[:customer_payment_profile_id])
+        xml.tag!('unmaskExpirationDate', options[:unmask_expiration_date]) if options[:unmask_expiration_date]
         xml.target!
       end
 

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

@@ -0,0 +1,243 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BarclaycardSmartpayGateway < Gateway
+      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.default_currency = 'EUR'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :dankort, :maestro]
+
+      self.homepage_url = 'https://www.barclaycardsmartpay.com/'
+      self.display_name = 'Barclaycard Smartpay'
+
+      def initialize(options = {})
+        requires!(options, :company, :merchant, :password)
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        MultiResponse.run do |r|
+          r.process { authorize(money, creditcard, options) }
+          r.process { capture(money, r.authorization, options) }
+        end
+      end
+
+      def authorize(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = payment_request(money, options)
+        post[:amount] = amount_hash(money, options[:currency])
+        post[:card] = credit_card_hash(creditcard)
+
+        if address = (options[:billing_address] || options[:address])
+          post[:billingAddress] = address_hash(address)
+        end
+
+        if options[:shipping_address]
+          post[:deliveryAddress] = address_hash(options[:shipping_address])
+        end
+
+        commit('authorise', post)
+      end
+
+      def capture(money, authorization, options = {})
+        requires!(options, :order_id)
+
+        post = modification_request(authorization, options)
+        post[:modificationAmount] = amount_hash(money, options[:currency])
+
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options = {})
+        requires!(options, :order_id)
+
+        post = modification_request(authorization, options)
+        post[:modificationAmount] = amount_hash(money, options[:currency])
+
+        commit('refund', post)
+      end
+
+      def void(identification, options = {})
+        requires!(options, :order_id)
+
+        post = modification_request(identification, options)
+
+        commit('cancel', post)
+      end
+
+      def verify(creditcard, options = {})
+        authorize(0, creditcard, options)
+      end
+
+      def store(creditcard, options = {})
+        # ??? require :email and :customer, :order_id?
+
+        post = store_request(options)
+        post[:card] = credit_card_hash(creditcard)
+        post[:recurring] = {:contract => 'RECURRING'}
+
+        commit('store', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r(((?:\r\n)?Authorization: Basic )[^\r\n]+(\r\n)?), '\1[FILTERED]').
+          gsub(%r((card.number=)\d+), '\1[FILTERED]').
+          gsub(%r((card.cvc=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def commit(action, post)
+        request = post_data(flatten_hash(post))
+        raw_response = ssl_post(build_url(action), request, headers)
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          test: test?,
+          authorization: response['recurringDetailReference'] || response['pspReference']
+        )
+
+      rescue ResponseError => e
+        case e.response.code
+        when '401'
+          return Response.new(false, 'Invalid credentials', {}, :test => test?)
+        when '422'
+          return Response.new(false, 'Unprocessable Entity', {}, :test => test?)
+        when '500'
+          if e.response.body.split(' ')[0] == 'validation'
+            return Response.new(false, e.response.body.split(' ', 3)[2], {}, :test => test?)
+          end
+        end
+        raise
+      end
+
+      def flatten_hash(hash, prefix = nil)
+        flat_hash = {}
+        hash.each_pair do |key, val|
+          conc_key = prefix.nil? ? key : "#{prefix}.#{key}"
+          if val.is_a?(Hash)
+            flat_hash.merge!(flatten_hash(val, conc_key))
+          else
+            flat_hash[conc_key] = val
+          end
+        end
+        flat_hash
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/x-www-form-urlencoded; charset=utf-8',
+          'Authorization' => 'Basic ' + Base64.encode64("ws@Company.#{@options[:company]}:#{@options[:password]}").strip
+        }
+      end
+
+      def parse(response)
+        Hash[
+          response.split('&').map do |x|
+            key, val = x.split('=', 2)
+            [key.split('.').last, CGI.unescape(val)]
+          end
+        ]
+      end
+
+      def post_data(data)
+        data.map do |key, val|
+          "#{key}=#{CGI.escape(val.to_s)}"
+        end.reduce do |x, y|
+          "#{x}&#{y}"
+        end
+      end
+
+      def message_from(response)
+        return response['resultCode'] if response.has_key?('resultCode') # Payment request
+        return response['response'] if response['response'] # Modification request
+        return response['result'] if response.has_key?('result') # Store/Recurring request
+        'Failure' # Negative fallback in case of error
+      end
+
+      def success_from(response)
+        return true if response.has_key?('authCode')
+        return true if response['result'] == 'Success'
+        successful_responses = %w([capture-received] [cancel-received] [refund-received])
+        successful_responses.include?(response['response'])
+      end
+
+      def build_url(action)
+        case action
+        when 'store'
+          "#{test? ? self.test_url : self.live_url}/Recurring/v12/storeToken"
+        else
+          "#{test? ? self.test_url : self.live_url}/Payment/v12/#{action}"
+        end
+      end
+
+      def address_hash(address)
+        full_address = "#{address[:address1]} #{address[:address2]}" if address
+
+        hash = {}
+        hash[:city]              = address[:city] if address[:city]
+        hash[:street]            = full_address.split(/\s+/).keep_if { |x| x !~ /\d/ }.join(' ')
+        hash[:houseNumberOrName] = full_address.split(/\s+/).keep_if { |x| x =~ /\d/ }.join(' ')
+        hash[:postalCode]        = address[:zip] if address[:zip]
+        hash[:stateOrProvince]   = address[:state] if address[:state]
+        hash[:country]           = address[:country] if address[:country]
+        hash
+      end
+
+      def amount_hash(money, currency)
+        hash = {}
+        hash[:currency] = currency || currency(money)
+        hash[:value]    = amount(money) if money
+        hash
+      end
+
+      def credit_card_hash(creditcard)
+        hash = {}
+        hash[:cvc]         = creditcard.verification_value if creditcard.verification_value
+        hash[:expiryMonth] = format(creditcard.month, :two_digits) if creditcard.month
+        hash[:expiryYear]  = format(creditcard.year, :four_digits) if creditcard.year
+        hash[:holderName]  = creditcard.name if creditcard.name
+        hash[:number]      = creditcard.number if creditcard.number
+        hash
+      end
+
+      def modification_request(reference, options)
+        hash = {}
+        hash[:merchantAccount]    = @options[:merchant]
+        hash[:originalReference]  = reference if reference
+        hash.keep_if { |_, v| v }
+      end
+
+      def payment_request(money, options)
+        hash = {}
+        hash[:merchantAccount]  = @options[:merchant]
+        hash[:reference]        = options[:order_id] if options[:order_id]
+        hash[:shopperEmail]     = options[:email] if options[:email]
+        hash[:shopperIP]        = options[:ip] if options[:ip]
+        hash[:shopperReference] = options[:customer] if options[:customer]
+        hash.keep_if { |_, v| v }
+      end
+
+      def store_request(options)
+        hash = {}
+        hash[:merchantAccount]  = @options[:merchant]
+        hash[:shopperEmail]     = options[:email] if options[:email]
+        hash[:shopperReference] = options[:customer] if options[:customer]
+        hash.keep_if { |_, v| v }
+      end
+    end
+  end
+end

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

@@ -252,7 +252,7 @@ module ActiveMerchant #:nodoc:
         end
 
         def message
-          params[:ProcessPaymentResult_AuthorisationResult]
+          params[:ProcessPaymentResult_AuthorisationResult] || params[:response_ResponseMessage]
         end
       end
 

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

@@ -321,7 +321,7 @@ module ActiveMerchant #:nodoc:
       def response_from_result(result)
         Response.new(result.success?, message_from_result(result),
           { braintree_transaction: transaction_hash(result) },
-          { authorization: (result.transaction.id if result.success?) }
+          { authorization: (result.transaction.id if result.transaction) }
          )
       end
 
@@ -334,10 +334,8 @@ module ActiveMerchant #:nodoc:
 
       def response_options(result)
         options = {}
-        if result.success?
-          options[:authorization] = result.transaction.id
-        end
         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
@@ -554,13 +552,15 @@ module ActiveMerchant #:nodoc:
             :last_name => credit_card_or_vault_id.last_name
           )
           if credit_card_or_vault_id.is_a?(NetworkTokenizationCreditCard)
-            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.first_name} #{credit_card_or_vault_id.last_name}",
-              :cryptogram => credit_card_or_vault_id.payment_cryptogram
-            }
+            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.first_name} #{credit_card_or_vault_id.last_name}",
+                :cryptogram => credit_card_or_vault_id.payment_cryptogram
+              }
+            end
           else
             parameters[:credit_card] = {
               :number => credit_card_or_vault_id.number,