activemerchant 1.75.0 → 1.76.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 50bb4461b27b49be6e87608a11f5db29a02d0adc
-  data.tar.gz: d5b76878be3ec6d7334cb343d439837b6fb3d599
+  metadata.gz: fe5e2a6f611e503ee6acfb6453f46b914f9b93c4
+  data.tar.gz: ecdf4eaa3a3d3697aa769239ac59ac4121f5d46a
 SHA512:
-  metadata.gz: 3eff219643c61371a81f0242548576dadfd8032cd3939a5859e6d5a8ca1aa4b822454754ed6aef844c14096af72a69b90b6ae5cb2ba8491fb662beba6aeb8447
-  data.tar.gz: 2cc15eaa916a7b90c66e8686668ec01cc56cebdfe2029c555033e2e1907fc931842e24bad2c8fb7760d543940cdfb6d84da0d8e1da24ccaa4927adc7646950d9
+  metadata.gz: 506d1d259018973cc2d4c9b6c37442f7fdc8903595a5cd6056ab32fa2608bef32d0e94d1f09179f2b660b99e1197c85c146f0afb0a60cd07a42432ebff0d5fc8
+  data.tar.gz: 8e8ca9a39966245232a7b64a685939e7852eab12f28fc3f1dc540b9e10a39c04517fd912bc609d56101e4e16d0165fe5b7a1f45570b009a35aaf27be09760284

data/CHANGELOG

@@ -2,6 +2,33 @@
 
 == HEAD
 
+== Version 1.76.0 (January 3, 2018)
+* PayU Latam: Change default text for description [nfarve] #2669
+* Checkout V2: Allows AVS and CVV result details to come through on authorizations [deedeelavinder] #2650
+* Global Collect: Adds boolean option for pre_authorization [deeedeelavinder] #2651
+* Credorax: Pass Transaction Type field [curiousepic] #2653
+* Add CardProcess Gateway [bpollack] #2659
+* Safe Charge: Provision 3DS option for approved merchants [deedeelavinder] #2661
+* PayU Latam: Require payment_country on initialize [curiousepic] #2663
+* Adyen: Remove CVV as Required Field and Determines shopperInteraction [nfarve] #2665
+* SafeCharge: add support for VendorID, WebsiteID, and IP logging [bpollack] #2667
+* Safe Charge: Adds 3DS flag [deedeelavinder] #2668
+* CardProcess: Fix success? to always return true or false [bpollack] #2674
+* SagePay: Correct CVV, AVS codes for Sagepay [singhai0] #2670
+* PayU Latam: Count pending Voids as successful [curiousepic] #2677
+* Mercado Pago: Ensure acess tokens are URL escaped [bpollack] #2675
+* MiGS: Update hash format to SHA256 and restore remote tests [bpollack] #2676
+* MiGS: Support verify calls [bpollack] #2664
+* iATS: Fix Messages with Failure on iATS Server [nfarve] #2680
+* Barclaycard Smartpay: Correct repsonse for fraud rejects #2683
+* Adyen: Allow incomplete addresses in some situations [bpollack] #2684
+* Paymentez: Add new gateway [bpollack] #2685
+* PayU Latam: Provide a mechanism to override the amount in verify [dtykocki] #2688
+* Mercado Pago: Support X-Device-Session-ID Header [bpollack] #2689
+* Mercado Pago: Support arbitrary additional_info JSON [bpollack] #2691
+* FirstData E4: Override ECI value for Apple Pay transactions with Discover [jasonwebster] #2671
+* Quickbooks: Add payment context to Quickbooks charges and refunds [bdewater] #2694
+
 == Version 1.75.0 (November 9, 2017)
 * Barclaycard Smartpay: Clean up test options hashes [bpollack] #2632
 * Barclaycard Smartpay: Extra data fields for credits [bpollack] #2631

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

@@ -45,6 +45,7 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, money, options)
         add_payment(post, payment)
         add_extra_data(post, options)
+        add_shopper_interaction(post,payment,options)
         add_address(post, options)
         commit('authorise', post)
       end
@@ -97,17 +98,21 @@ module ActiveMerchant #:nodoc:
         post[:selectedBrand] = options[:selected_brand] if options[:selected_brand]
         post[:deliveryDate] = options[:delivery_date] if options[:delivery_date]
         post[:merchantOrderReference] = options[:merchant_order_reference] if options[:merchant_order_reference]
-        post[:shopperInteraction] = options[:shopper_interaction] if options[:shopper_interaction]
+      end
+
+      def add_shopper_interaction(post, payment, options={})
+        shopper_interaction = payment.verification_value ?  "Ecommerce" : "ContAuth"
+        post[:shopperInteraction] = options[:shopper_interaction] || shopper_interaction
       end
 
       def add_address(post, options)
         return unless post[:card] && post[:card].kind_of?(Hash)
-        if address = options[:billing_address] || options[:address]
+        if (address = options[:billing_address] || options[:address]) && address[:country]
           post[:card][:billingAddress] = {}
-          post[:card][:billingAddress][:street] = address[:address1] if address[:address1]
-          post[:card][:billingAddress][:houseNumberOrName] = address[:address2] if address[:address2]
+          post[:card][:billingAddress][:street] = address[:address1] || 'N/A'
+          post[:card][:billingAddress][:houseNumberOrName] = address[:address2] || 'N/A'
           post[:card][:billingAddress][:postalCode] = address[:zip] if address[:zip]
-          post[:card][:billingAddress][:city] = address[:city] if address[:city]
+          post[:card][:billingAddress][:city] = address[:city] || 'N/A'
           post[:card][:billingAddress][:stateOrProvince] = address[:state] if address[:state]
           post[:card][:billingAddress][:country] = address[:country] if address[:country]
         end
@@ -138,8 +143,9 @@ module ActiveMerchant #:nodoc:
           number: payment.number,
           cvc: payment.verification_value
         }
+
         card.delete_if{|k,v| v.blank? }
-        requires!(card, :expiryMonth, :expiryYear, :holderName, :number, :cvc)
+        requires!(card, :expiryMonth, :expiryYear, :holderName, :number)
         post[:card] = card
       end
 

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

@@ -211,8 +211,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response)
-        return true if response.has_key?('authCode')
         return true if response['result'] == 'Success'
+        return true if response['resultCode'] == 'Authorised'
         return true if response['resultCode'] == 'Received'
         successful_responses = %w([capture-received] [cancel-received] [refund-received])
         successful_responses.include?(response['response'])

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

@@ -0,0 +1,254 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CardprocessGateway < Gateway
+      self.test_url = 'https://test.vr-pay-ecommerce.de/v1/payments'
+      self.live_url = 'https://vr-pay-ecommerce.de/v1/payments'
+
+      self.supported_countries = %w[ BE BG CZ DK DE EE IE ES FR HR IT CY LV LT LU
+                                     MT HU NL AT PL PT RO SI SK FI SE GB IS LI NO
+                                     CH ME MK AL RS TR BA ]
+      self.default_currency = 'EUR'
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
+
+      self.homepage_url = 'https://vr-pay-ecommerce.docs.oppwa.com/'
+      self.display_name = 'CardProcess VR-Pay'
+      self.money_format = :dollars
+
+      STANDARD_ERROR_CODE_MAPPING = {}
+
+      # Creates a new CardProcess Gateway
+      #
+      # The gateway requires a valid login, password, and entity ID
+      # to be passed in the +options+ hash.
+      #
+      # === Options
+      #
+      # * <tt>:user_id</tt> -- The CardProcess user ID
+      # * <tt>:password</tt> -- The CardProcess password
+      # * <tt>:entity_id</tt> -- The CardProcess channel or entity ID for any transactions
+      def initialize(options={})
+        requires!(options, :user_id, :password, :entity_id)
+        super
+        # This variable exists purely to allow remote tests to force error codes;
+        # the lack of a setter despite its usage is intentional.
+        @test_options = {}
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('DB', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('PA', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {
+          id: authorization
+        }
+        add_invoice(post, money, options)
+        commit('CP', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {
+          id: authorization
+        }
+        add_invoice(post, money, options)
+        commit('RF', post)
+      end
+
+      def credit(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('CD', post)
+      end
+
+      def void(authorization, _options = {})
+        post = {
+          id: authorization
+        }
+        commit('RV', post)
+      end
+
+      def verify(credit_card, options = {})
+        MultiResponse.run do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript
+          .gsub(%r{(authentication\.[^=]+=)[^&]+}, '\1[FILTERED]')
+          .gsub(%r{(card\.number=)\d+}, '\1[FILTERED]')
+          .gsub(%r{(cvv=)\d{3,4}}, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post['customer.ip'] = options[:ip] if options[:ip]
+      end
+
+      def add_address(post, _card, options)
+        if (address = options[:billing_address] || options[:address])
+          post[:billing] = hashify_address(address)
+        end
+
+        if (shipping = options[:shipping_address])
+          post[:shipping] = hashify_address(shipping)
+        end
+      end
+
+      def add_invoice(post, money, options)
+        return if money.nil?
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:merchantInvoiceId] = options[:merchant_invoice_id] if options[:merchant_invoice_id]
+        post[:merchantTransactionId] = options[:merchant_transaction_id] if options[:merchant_transaction_id]
+        post[:transactionCategory] = options[:transaction_category] if options[:transaction_category]
+      end
+
+      def add_payment(post, payment)
+        return if payment.is_a?(String)
+        post[:paymentBrand] = payment.brand.upcase if payment.brand
+        post[:card] ||= {}
+        post[:card][:number] = payment.number
+        post[:card][:holder] = payment.name
+        post[:card][:expiryMonth] = sprintf('%02d', payment.month)
+        post[:card][:expiryYear] = sprintf('%02d', payment.year)
+        post[:card][:cvv] = payment.verification_value
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, parameters)
+        url = (test? ? test_url : live_url)
+        if (id = parameters.delete(:id))
+          url += "/#{id}"
+        end
+
+        begin
+          raw_response = ssl_post(url, post_data(action, parameters.merge(@test_options)))
+        rescue ResponseError => e
+          raw_response = e.response.body
+        end
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: response['result']['avsResponse']),
+          cvv_result: CVVResult.new(response['result']['cvvResponse']),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        !(response['result']['code'] =~ /^(000\.000\.|000\.100\.1|000\.[36])/).nil?
+      end
+
+      def message_from(response)
+        response['result']['description']
+      end
+
+      def authorization_from(response)
+        response['id']
+      end
+
+      def post_data(action, parameters = {})
+        post = parameters.clone
+        post[:authentication] ||= {}
+        post[:authentication][:userId] = @options[:user_id]
+        post[:authentication][:password] = @options[:password]
+        post[:authentication][:entityId] = @options[:entity_id]
+        post[:paymentType] = action
+        dot_flatten_hash(post).map {|key, value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          case response['result']['code']
+          when '100.100.101'
+            STANDARD_ERROR_CODE[:incorrect_number]
+          when '100.100.303'
+            STANDARD_ERROR_CODE[:expired_card]
+          when /100\.100\.(201|301|305)/
+            STANDARD_ERROR_CODE[:invalid_expiry_date]
+          when /100.100.60[01]/
+            STANDARD_ERROR_CODE[:invalid_cvc]
+          when '800.100.151'
+            STANDARD_ERROR_CODE[:invalid_number]
+          when '800.100.153'
+            STANDARD_ERROR_CODE[:incorrect_cvc]
+          when /800.800.(102|302)/
+            STANDARD_ERROR_CODE[:incorrect_address]
+          when '800.800.202'
+            STANDARD_ERROR_CODE[:invalid_zip]
+          when '800.100.166'
+            STANDARD_ERROR_CODE[:incorrect_pin]
+          when '800.100.171'
+            STANDARD_ERROR_CODE[:pickup_card]
+          when /^(200|700)\./
+            STANDARD_ERROR_CODE[:config_error]
+          when /^(800\.[17]00|800\.800\.[123])/
+            STANDARD_ERROR_CODE[:card_declined]
+          when /^(900\.[1234]00)/
+            STANDARD_ERROR_CODE[:processing_error]
+          else
+            STANDARD_ERROR_CODE[:processing_error]
+          end
+        end
+      end
+
+      def hashify_address(address)
+        hash = {}
+        hash[:street1] = address[:address1] if address[:address1]
+        hash[:street2] = address[:address2] if address[:address2]
+        hash[:city] = address[:city] if address[:city]
+        hash[:state] = address[:state] if address[:state]
+        hash[:postcode] = address[:zip] if address[:zip]
+        hash[:country] = address[:country] if address[:country]
+        hash
+      end
+
+      def dot_flatten_hash(hash, prefix = '')
+        h = {}
+        hash.each_pair do |k, v|
+          if v.is_a?(Hash)
+            h.merge!(dot_flatten_hash(v, prefix + k.to_s + '.'))
+          else
+            h[prefix + k.to_s] = v
+          end
+        end
+        h
+      end
+    end
+  end
+end

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

@@ -25,16 +25,7 @@ module ActiveMerchant #:nodoc:
         merged_params = multi.responses.map { |r| r.params }.reduce({}, :merge)
         succeeded = success_from(merged_params)
 
-        Response.new(
-          succeeded,
-          message_from(succeeded, merged_params),
-          merged_params,
-          authorization: authorization_from(merged_params),
-          avs_result: avs_result(:purchase, succeeded, merged_params),
-          cvv_result: cvv_result(:purchase, succeeded, merged_params),
-          error_code: error_code_from(succeeded, merged_params),
-          test: test?
-        )
+        response(:purchase, succeeded, merged_params)
       end
 
       def authorize(amount, payment_method, options={})
@@ -132,6 +123,15 @@ module ActiveMerchant #:nodoc:
         end
 
         succeeded = success_from(response)
+
+        response(action, succeeded, response)
+      end
+
+      def response(action, succeeded, response)
+        successful_response = succeeded && action == :purchase || action == :authorize
+        avs_result = successful_response ? avs_result(response) : nil
+        cvv_result = successful_response ? cvv_result(response) : nil
+
         Response.new(
           succeeded,
           message_from(succeeded, response),
@@ -139,8 +139,9 @@ module ActiveMerchant #:nodoc:
           authorization: authorization_from(response),
           error_code: error_code_from(succeeded, response),
           test: test?,
-          avs_result: avs_result(action, succeeded, response),
-          cvv_result: cvv_result(action, succeeded, response))
+          avs_result: avs_result,
+          cvv_result: cvv_result
+        )
       end
 
       def headers
@@ -162,20 +163,12 @@ module ActiveMerchant #:nodoc:
         test? ? test_url : live_url
       end
 
-      def avs_result(action, succeeded, response)
-        if succeeded
-          action == :purchase ? AVSResult.new(code: response["card"]["avsCheck"]) : nil
-        else
-          nil
-        end
+      def avs_result(response)
+        response['card'] && response['card']['avsCheck'] ? AVSResult.new(code: response['card']['avsCheck']) : nil
       end
 
-      def cvv_result(action, succeeded, response)
-        if succeeded
-          action == :purchase ? CVVResult.new(response["card"]["cvvCheck"]) : nil
-        else
-          nil
-        end
+      def cvv_result(response)
+        response['card'] && response['card']['cvvCheck'] ? CVVResult.new(response['card']['cvvCheck']) : nil
       end
 
       def parse(body)

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

@@ -129,6 +129,7 @@ module ActiveMerchant #:nodoc:
         add_email(post, options)
         add_3d_secure(post, options)
         add_echo(post, options)
+        add_transaction_type(post, options)
 
         commit(:purchase, post)
       end
@@ -141,6 +142,7 @@ module ActiveMerchant #:nodoc:
         add_email(post, options)
         add_3d_secure(post, options)
         add_echo(post, options)
+        add_transaction_type(post, options)
 
         commit(:authorize, post)
       end
@@ -182,7 +184,8 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, options)
         add_email(post, options)
         add_echo(post, options)
-
+        add_transaction_type(post, options)
+        
         commit(:credit, post)
       end
 
@@ -264,6 +267,10 @@ module ActiveMerchant #:nodoc:
         post[:d2] = options[:echo] unless options[:echo].blank?
       end
 
+      def add_transaction_type(post, options)
+        post[:a9] = options[:transaction_type] if options[:transaction_type]
+      end
+
       ACTIONS = {
         purchase: '1',
         authorize: '2',

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

@@ -237,13 +237,24 @@ module ActiveMerchant #:nodoc:
           xml.tag! "CardHoldersName", credit_card.name
           xml.tag! "CardType", card_type(credit_card.brand)
 
-          eci = (credit_card.respond_to?(:eci) ? credit_card.eci : nil) || options[:eci] || DEFAULT_ECI
-          xml.tag! "Ecommerce_Flag", eci.to_s =~ /^[0-9]+$/ ? eci.to_s.rjust(2, '0') : eci
-
+          add_credit_card_eci(xml, credit_card, options)
           add_credit_card_verification_strings(xml, credit_card, options)
         end
       end
 
+      def add_credit_card_eci(xml, credit_card, options)
+        eci = if credit_card.is_a?(NetworkTokenizationCreditCard) && credit_card.source == :apple_pay && card_brand(credit_card) == "discover"
+          # Discover requires any Apple Pay transaction, regardless of in-app
+          # or web, and regardless of the ECI contained in the PKPaymentToken,
+          # to have an ECI value explicitly of 04.
+          "04"
+        else
+          (credit_card.respond_to?(:eci) ? credit_card.eci : nil) || options[:eci] || DEFAULT_ECI
+        end
+
+        xml.tag! "Ecommerce_Flag", eci.to_s =~ /^[0-9]+$/ ? eci.to_s.rjust(2, '0') : eci
+      end
+
       def add_credit_card_verification_strings(xml, credit_card, options)
         address = options[:billing_address] || options[:address]
         if address

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

@@ -30,7 +30,7 @@ module ActiveMerchant #:nodoc:
       def authorize(money, payment, options={})
         post = nestable_hash
         add_order(post, money, options)
-        add_payment(post, payment)
+        add_payment(post, payment, options)
         add_customer_data(post, options, payment)
         add_address(post, payment, options)
 
@@ -106,15 +106,17 @@ module ActiveMerchant #:nodoc:
         }
       end
 
-      def add_payment(post, payment)
+      def add_payment(post, payment, options)
         year  = format(payment.year, :two_digits)
         month = format(payment.month, :two_digits)
         expirydate =   "#{month}#{year}"
+        pre_authorization = options[:pre_authorization] ? 'PRE_AUTHORIZATION' : 'FINAL_AUTHORIZATION'
 
         post["cardPaymentMethodSpecificInput"] = {
             "paymentProductId" => BRAND_MAP[payment.brand],
             "skipAuthentication" => "true", # refers to 3DSecure
-            "skipFraudService" => "true"
+            "skipFraudService" => "true",
+            "authorizationMode" => pre_authorization
         }
         post["cardPaymentMethodSpecificInput"]["card"] = {
             "cvv" => payment.verification_value,

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

@@ -225,7 +225,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def successful_result_message?(response)
-        response[:authorization_result].start_with?('OK')
+        response[:authorization_result] ? response[:authorization_result].start_with?('OK') : false
       end
 
       def success_from(response)
@@ -233,7 +233,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def message_from(response)
-        if(!successful_result_message?(response))
+        if !successful_result_message?(response) && response[:authorization_result]
           return response[:authorization_result].strip
         elsif(response[:status] == 'Failure')
           return response[:errors]

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

@@ -114,9 +114,11 @@ module ActiveMerchant #:nodoc:
 
       def add_additional_data(post, options)
         post[:sponsor_id] = options[:sponsor_id]
+        post[:device_id] = options[:device_id] if options[:device_id]
         post[:additional_info] = {
           ip_address: options[:ip_address]
-        }
+        }.merge(options[:additional_info] || {})
+
 
         add_address(post, options)
         add_shipping_address(post, options)
@@ -191,7 +193,7 @@ module ActiveMerchant #:nodoc:
         if ["capture", "void"].include?(action)
           response = parse(ssl_request(:put, url(path), post_data(parameters), headers))
         else
-          response = parse(ssl_post(url(path), post_data(parameters), headers))
+          response = parse(ssl_post(url(path), post_data(parameters), headers(parameters)))
         end
 
         Response.new(
@@ -221,7 +223,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def post_data(parameters = {})
-        parameters.to_json
+        parameters.clone.tap { |p| p.delete(:device_id) }.to_json
       end
 
       def error_code_from(action, response)
@@ -236,13 +238,15 @@ module ActiveMerchant #:nodoc:
 
       def url(action)
         full_url = (test? ? test_url : live_url)
-        full_url + "/#{action}?access_token=#{@options[:access_token]}"
+        full_url + "/#{action}?access_token=#{CGI.escape(@options[:access_token])}"
       end
 
-      def headers
-        {
+      def headers(options = {})
+        headers = {
           "Content-Type" => "application/json"
         }
+        headers['X-Device-Session-ID'] = options[:device_id] if options[:device_id]
+        headers
       end
 
       def handle_response(response)

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

@@ -1,6 +1,6 @@
 require 'active_merchant/billing/gateways/migs/migs_codes'
 
-require 'digest/md5' # Used in add_secure_hash
+require 'openssl' # Used in add_secure_hash
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -121,6 +121,13 @@ module ActiveMerchant #:nodoc:
         refund(money, authorization, options)
       end
 
+      def verify(credit_card, options={})
+        MultiResponse.run do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
       # Checks the status of a previous transaction
       # This can be useful when a response is not received due to network issues
       #
@@ -187,7 +194,7 @@ module ActiveMerchant #:nodoc:
 
         response_hash = parse(data)
 
-        expected_secure_hash = calculate_secure_hash(response_hash.reject{|k, v| k == :SecureHash}, @options[:secure_hash])
+        expected_secure_hash = calculate_secure_hash(response_hash, @options[:secure_hash])
         unless response_hash[:SecureHash] == expected_secure_hash
           raise SecurityError, "Secure Hash mismatch, response may be tampered with"
         end
@@ -245,6 +252,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(post)
+        add_secure_hash(post) if @options[:secure_hash]
         data = ssl_post self.merchant_hosted_url, post_data(post)
         response_hash = parse(data)
         response_object(response_hash)
@@ -290,12 +298,16 @@ module ActiveMerchant #:nodoc:
 
       def add_secure_hash(post)
         post[:SecureHash] = calculate_secure_hash(post, @options[:secure_hash])
+        post[:SecureHashType] = 'SHA256'
       end
 
       def calculate_secure_hash(post, secure_hash)
-        sorted_values = post.sort_by(&:to_s).map(&:last)
-        input = secure_hash + sorted_values.join
-        Digest::MD5.hexdigest(input).upcase
+        input = post
+                .reject { |k| %i[SecureHash SecureHashType].include?(k) }
+                .sort
+                .map { |(k, v)| "vpc_#{k}=#{v}" }
+                .join('&')
+        OpenSSL::HMAC.hexdigest('SHA256', [secure_hash].pack('H*'), input).upcase
       end
     end
   end

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

@@ -0,0 +1,273 @@
+require 'base64'
+require 'digest'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaymentezGateway < Gateway #:nodoc:
+      self.test_url = 'https://ccapi-stg.paymentez.com/v2/'
+      self.live_url = 'https://ccapi.paymentez.com/v2/'
+
+      self.supported_countries = %w[MX EC VE CO BR CL]
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express diners_club]
+
+      self.homepage_url = 'https://secure.paymentez.com/'
+      self.display_name = 'Paymentez'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        1 => :processing_error,
+        6 => :card_declined,
+        9 => :card_declined,
+        10 => :processing_error,
+        11 => :card_declined,
+        12 => :config_error,
+        13 => :config_error,
+        19 => :invalid_cvc,
+        20 => :config_error,
+        21 => :card_declined,
+        22 => :card_declined,
+        23 => :card_declined,
+        24 => :card_declined,
+        25 => :card_declined,
+        26 => :card_declined,
+        27 => :card_declined,
+        28 => :card_declined
+      }.freeze
+
+      CARD_MAPPING = {
+        'visa' => 'vi',
+        'master' => 'mc',
+        'american_express' => 'ax',
+        'diners_club' => 'di'
+      }.freeze
+
+      def initialize(options = {})
+        requires!(options, :application_code, :app_key)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_customer_data(post, options)
+
+        commit_transaction('debit_cc', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+
+        add_invoice(post, money, options)
+        add_customer_data(post, options)
+
+        MultiResponse.run do |r|
+          r.process { store(payment, options) }
+          post[:card] = { token: r.authorization }
+          r.process { commit_transaction('authorize', post) }
+        end
+      end
+
+      def capture(_money, authorization, _options = {})
+        post = { transaction: { id: authorization } }
+
+        commit_transaction('capture', post)
+      end
+
+      def refund(_money, authorization, options = {})
+        void(authorization, options)
+      end
+
+      def void(authorization, _options = {})
+        post = { transaction: { id: authorization } }
+        commit_transaction('refund', post)
+      end
+
+      def verify(credit_card, options = {})
+        MultiResponse.run do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process { void(r.authorization, options) }
+        end
+      end
+
+      def store(credit_card, options = {})
+        post = {}
+
+        add_customer_data(post, options)
+        add_payment(post, credit_card)
+
+        response = commit_card('add', post)
+        if !response.success? && !(token = extract_previous_card_token(response)).nil?
+          unstore(token, options)
+          response = commit_card('add', post)
+        end
+        response
+      end
+
+      def unstore(identification, options = {})
+        post = { card: { token: identification }, user: { id: options[:user_id] }}
+        commit_card('delete', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript
+          .gsub(%r{(\\?"number\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]')
+          .gsub(%r{(\\?"cvc\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]')
+          .gsub(%r{(Auth-Token: )([A-Za-z0-9=]+)}, '\1[FILTERED]')
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        requires!(options, :user_id, :email)
+        post[:user] ||= {}
+        post[:user][:id] = options[:user_id]
+        post[:user][:email] = options[:email]
+        post[:user][:ip_address] = options[:ip] if options[:ip]
+        post[:user][:fiscal_number] = options[:fiscal_number] if options[:fiscal_number]
+      end
+
+      def add_invoice(post, money, options)
+        post[:session_id] = options[:session_id] if options[:session_id]
+
+        post[:order] ||= {}
+        post[:order][:amount] = amount(money).to_f
+        post[:order][:vat] = options[:vat] if options[:vat]
+        post[:order][:dev_reference] = options[:dev_reference] if options[:dev_reference]
+        post[:order][:description] = options[:description] if options[:description]
+        post[:order][:discount] = options[:discount] if options[:discount]
+        post[:order][:installments] = options[:installments] if options[:installments]
+        post[:order][:installments_type] = options[:installments_type] if options[:installments_type]
+        post[:order][:taxable_amount] = options[:taxable_amount] if options[:taxable_amount]
+      end
+
+      def add_payment(post, payment)
+        post[:card] ||= {}
+        post[:card][:number] = payment.number
+        post[:card][:holder_name] = payment.name
+        post[:card][:expiry_month] = payment.month
+        post[:card][:expiry_year] = payment.year
+        post[:card][:cvc] = payment.verification_value
+        post[:card][:type] = CARD_MAPPING[payment.brand]
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit_raw(object, action, parameters)
+        url = "#{(test? ? test_url : live_url)}#{object}/#{action}"
+
+        begin
+          raw_response = ssl_post(url, post_data(parameters), headers)
+        rescue ResponseError => e
+          raw_response = e.response.body
+        end
+        parse(raw_response)
+      end
+
+      def commit_transaction(action, parameters)
+        response = commit_raw('transaction', action, parameters)
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def commit_card(action, parameters)
+        response = commit_raw('card', action, parameters)
+        Response.new(
+          card_success_from(response),
+          card_message_from(response),
+          response,
+          authorization: card_authorization_from(response),
+          test: test?,
+          error_code: card_error_code_from(response)
+        )
+      end
+
+      def headers
+        {
+          'Auth-Token' => authentication_code,
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      def success_from(response)
+        !response.include?('error') && (response['status'] || response['transaction']['status']) == 'success'
+      end
+
+      def card_success_from(response)
+        return false if response.include?('error')
+        return true if response['message'] == 'card deleted'
+        response['card']['status'] == 'valid'
+      end
+
+      def message_from(response)
+        if success_from(response)
+          response['transaction'] && response['transaction']['message']
+        else
+          response['error'] && response['error']['type']
+        end
+      end
+
+      def card_message_from(response)
+        if !response.include?('error')
+          response['message'] || response['card']['message']
+        else
+          response['error']['type']
+        end
+      end
+
+      def authorization_from(response)
+        response['transaction'] && response['transaction']['id']
+      end
+
+      def card_authorization_from(response)
+        response['card'] && response['card']['token']
+      end
+
+      def extract_previous_card_token(response)
+        match = /Card already added: (\d+)/.match(response.message)
+        match && match[1]
+      end
+
+      def post_data(parameters = {})
+        JSON.dump(parameters)
+      end
+
+      def error_code_from(response)
+        return if success_from(response)
+        if response['transaction']
+          detail = response['transaction']['status_detail']
+          if STANDARD_ERROR_CODE_MAPPING.include?(detail)
+            return STANDARD_ERROR_CODE[STANDARD_ERROR_CODE_MAPPING[detail]]
+          end
+        elsif response['error']
+          return STANDARD_ERROR_CODE[:config_error]
+        end
+        STANDARD_ERROR_CODE[:processing_error]
+      end
+
+      def card_error_code_from(response)
+        STANDARD_ERROR_CODE[:processing_error] unless card_success_from(response)
+      end
+
+      def authentication_code
+        timestamp = Time.new.to_i
+        unique_token = Digest::SHA256.hexdigest("#{@options[:app_key]}#{timestamp}")
+        authentication_string = "#{@options[:application_code]};#{timestamp};#{unique_token}"
+        Base64.encode64(authentication_string).delete("\n")
+      end
+    end
+  end
+end

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

@@ -29,9 +29,8 @@ module ActiveMerchant #:nodoc:
       }
 
       def initialize(options={})
-        requires!(options, :merchant_id, :account_id, :api_login, :api_key)
+        requires!(options, :merchant_id, :account_id, :api_login, :api_key, :payment_country)
         super
-        @options[:payment_country] ||= options[:payment_country] if options[:payment_country]
       end
 
       def purchase(amount, payment_method, options={})
@@ -78,7 +77,7 @@ module ActiveMerchant #:nodoc:
 
       def verify(credit_card, options={})
         minimum = MINIMUMS[options[:currency].upcase] if options[:currency]
-        amount = minimum || 100
+        amount = options[:verify_amount] || minimum || 100
 
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(amount, credit_card, options) }
@@ -139,7 +138,7 @@ module ActiveMerchant #:nodoc:
 
       def add_transaction_elements(post, type, options)
         transaction = {}
-        transaction[:paymentCountry] = @options[:payment_country] || (options[:billing_address][:country] if options[:billing_address])
+        transaction[:paymentCountry] = @options[:payment_country]
         transaction[:type] = type
         transaction[:ipAddress] = options[:ip] || ''
         transaction[:userAgent] = options[:user_agent] if options[:user_agent]
@@ -153,7 +152,7 @@ module ActiveMerchant #:nodoc:
         order[:accountId] = @options[:account_id]
         order[:partnerId] = options[:partner_id] if options[:partner_id]
         order[:referenceCode] = options[:order_id] || generate_unique_id
-        order[:description] = options[:description] || 'unspecified'
+        order[:description] = options[:description] || 'Compra en ' + @options[:merchant_id]
         order[:language] = 'en'
         order[:shippingAddress] = shipping_address_fields(options) if options[:shipping_address]
         post[:transaction][:order] = order
@@ -167,7 +166,7 @@ module ActiveMerchant #:nodoc:
         payer[:dniNumber] = options[:dni_number] if options[:dni_number]
         payer[:dniType] = options[:dni_type] if options[:dni_type]
         payer[:emailAddress] = options[:email] if options[:email]
-        payer[:birthdate] = options[:birth_date] if options[:birth_date] && options[:payment_country] == 'MX'
+        payer[:birthdate] = options[:birth_date] if options[:birth_date] && @options[:payment_country] == 'MX'
         payer[:billingAddress] = billing_address_fields(options)
         post[:transaction][:payer] = payer
       end
@@ -180,7 +179,7 @@ module ActiveMerchant #:nodoc:
         billing_address[:city] = address[:city]
         billing_address[:state] = address[:state]
         billing_address[:country] = address[:country]
-        billing_address[:postalCode] = address[:zip] if options[:payment_country] == 'MX'
+        billing_address[:postalCode] = address[:zip] if @options[:payment_country] == 'MX'
         billing_address[:phone] = address[:phone]
         billing_address
       end
@@ -191,7 +190,7 @@ module ActiveMerchant #:nodoc:
           buyer[:fullName] = buyer_hash[:name]
           buyer[:dniNumber] = buyer_hash[:dni_number]
           buyer[:dniType] = buyer_hash[:dni_type]
-          buyer[:cnpj] = buyer_hash[:cnpj] if options[:payment_country] == 'BR'
+          buyer[:cnpj] = buyer_hash[:cnpj] if @options[:payment_country] == 'BR'
           buyer[:emailAddress] = buyer_hash[:email]
           buyer[:contactPhone] = (options[:billing_address][:phone] if options[:billing_address]) || (options[:shipping_address][:phone] if options[:shipping_address]) || ''
           buyer[:shippingAddress] = shipping_address_fields(options) if options[:shipping_address]
@@ -199,7 +198,7 @@ module ActiveMerchant #:nodoc:
           buyer[:fullName] = payment_method.name.strip
           buyer[:dniNumber] = options[:dni_number]
           buyer[:dniType] = options[:dni_type]
-          buyer[:cnpj] = options[:cnpj] if options[:payment_country] == 'BR'
+          buyer[:cnpj] = options[:cnpj] if @options[:payment_country] == 'BR'
           buyer[:emailAddress] = options[:email]
           buyer[:contactPhone] = (options[:billing_address][:phone] if options[:billing_address]) || (options[:shipping_address][:phone] if options[:shipping_address]) || ''
           buyer[:shippingAddress] = shipping_address_fields(options) if options[:shipping_address]
@@ -235,8 +234,8 @@ module ActiveMerchant #:nodoc:
 
         additional_values = {}
         additional_values[:TX_VALUE] = tx_value
-        additional_values[:TX_TAX] = tx_tax if options[:payment_country] == 'CO'
-        additional_values[:TX_TAX_RETURN_BASE] = tx_tax_return_base if options[:payment_country] == 'CO'
+        additional_values[:TX_TAX] = tx_tax if @options[:payment_country] == 'CO'
+        additional_values[:TX_TAX_RETURN_BASE] = tx_tax_return_base if @options[:payment_country] == 'CO'
 
         post[:transaction][:order][:additionalValues] = additional_values
       end
@@ -358,7 +357,7 @@ module ActiveMerchant #:nodoc:
           response["code"] == "SUCCESS" && response["creditCardToken"] && response["creditCardToken"]["creditCardTokenId"].present?
         when 'verify_credentials'
           response["code"] == "SUCCESS"
-        when 'refund'
+        when 'refund', 'void'
         response["code"] == "SUCCESS" && response["transactionResponse"] && (response["transactionResponse"]["state"] == "PENDING" || response["transactionResponse"]["state"] == "APPROVED")
         else
           response["code"] == "SUCCESS" && response["transactionResponse"] && (response["transactionResponse"]["state"] == "APPROVED")
@@ -375,8 +374,10 @@ module ActiveMerchant #:nodoc:
           return "VERIFIED" if success
           "FAILED"
         else
-          response_message = response["transactionResponse"]["responseMessage"] if response["transactionResponse"]
-          response_code = response["transactionResponse"]["responseCode"] if response["transactionResponse"]
+          if response["transactionResponse"]
+            response_message = response["transactionResponse"]["responseMessage"]
+            response_code = response["transactionResponse"]["responseCode"] || response["transactionResponse"]["pendingReason"]
+          end
           return response_code if success
           response["error"] || response_message || response_code || "FAILED"
         end

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

@@ -78,6 +78,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         capture_uri = "#{ENDPOINT}/#{CGI.escape(authorization)}/capture"
         post[:amount] = localized_amount(money, currency(money))
+        add_context(post, options)
 
         commit(capture_uri, post)
       end
@@ -85,6 +86,7 @@ module ActiveMerchant #:nodoc:
       def refund(money, authorization, options = {})
         post = {}
         post[:amount] = localized_amount(money, currency(money))
+        add_context(post, options)
 
         commit(refund_uri(authorization), post)
       end
@@ -137,6 +139,7 @@ module ActiveMerchant #:nodoc:
 
       def add_payment(post, payment, options = {})
         add_creditcard(post, payment, options)
+        add_context(post, options)
       end
 
       def add_creditcard(post, creditcard, options = {})
@@ -151,6 +154,13 @@ module ActiveMerchant #:nodoc:
         post[:card] = card
       end
 
+      def add_context(post, options = {})
+        post[:context] = {
+          mobile: options.fetch(:mobile, false),
+          isEcommerce: options.fetch(:ecommerce, true)
+        }
+      end
+
       def parse(body)
         JSON.parse(body)
       end

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

@@ -22,7 +22,9 @@ module ActiveMerchant #:nodoc:
 
       def purchase(money, payment, options={})
         post = {}
-        add_transaction_data("Sale", post, money, options)
+        post[:sg_APIType] = 1 if options[:three_d_secure]
+        trans_type = options[:three_d_secure] ? "Sale3D" : "Sale"
+        add_transaction_data(trans_type, post, money, options)
         add_payment(post, payment)
         add_customer_details(post, payment, options)
 
@@ -120,6 +122,9 @@ module ActiveMerchant #:nodoc:
         post[:sg_UserID] = options[:user_id] if options[:user_id]
         post[:sg_AuthType] = options[:auth_type] if options[:auth_type]
         post[:sg_ExpectedFulfillmentCount] = options[:expected_fulfillment_count] if options[:expected_fulfillment_count]
+        post[:sg_WebsiteID] = options[:website_id] if options[:website_id]
+        post[:sg_IPAddress] = options[:ip] if options[:ip]
+        post[:sg_VendorID] = options[:vendor_id] if options[:vendor_id]
       end
 
       def add_payment(post, payment)
@@ -150,21 +155,32 @@ module ActiveMerchant #:nodoc:
 
         doc = Nokogiri::XML(xml)
         doc.root.xpath('*').each do |node|
-          response[node.name.underscore.downcase.to_sym] = node.text
+          if node.elements.size == 0
+            response[node.name.underscore.downcase.to_sym] = node.text
+          else
+            node.traverse do |childnode|
+              childnode_to_response(response, childnode)
+            end
+          end
         end
-
         response
       end
 
-      def childnode_to_response(response, node, childnode)
-        name = "#{node.name.downcase}_#{childnode.name.downcase}"
-        if name == 'payment_method_data' && !childnode.elements.empty?
-          response[name.to_sym] = Hash.from_xml(childnode.to_s).values.first
+      def childnode_to_response(response, childnode)
+        if childnode.elements.size == 0
+          element_name_to_symbol(response, childnode)
         else
-          response[name.to_sym] = childnode.text
+          childnode.traverse do |childnode|
+            element_name_to_symbol(response, childnode)
+          end
         end
       end
 
+      def element_name_to_symbol(response, childnode)
+        name = "#{childnode.name.downcase}"
+        response[name.to_sym] = childnode.text
+      end
+
       def commit(parameters)
         url = (test? ? test_url : live_url)
         response = parse(ssl_post(url, post_data(parameters)))

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

@@ -37,13 +37,20 @@ module ActiveMerchant #:nodoc:
         :jcb => "JCB"
       }
 
-      AVS_CVV_CODE = {
+      AVS_CODE = {
         "NOTPROVIDED" => nil,
         "NOTCHECKED" => 'X',
         "MATCHED" => 'Y',
         "NOTMATCHED" => 'N'
       }
 
+      CVV_CODE = {
+        "NOTPROVIDED" => 'S',
+        "NOTCHECKED" => 'X',
+        "MATCHED" => 'M',
+        "NOTMATCHED" => 'N'
+      }
+
       OPTIONAL_REQUEST_FIELDS = {
         paypal_callback_url: :PayPalCallbackURL,
         basket: :Basket,
@@ -348,10 +355,10 @@ module ActiveMerchant #:nodoc:
           :test => test?,
           :authorization => authorization_from(response, parameters, action),
           :avs_result => {
-            :street_match => AVS_CVV_CODE[ response["AddressResult"] ],
-            :postal_match => AVS_CVV_CODE[ response["PostCodeResult"] ],
+            :street_match => AVS_CODE[ response["AddressResult"] ],
+            :postal_match => AVS_CODE[ response["PostCodeResult"] ],
           },
-          :cvv_result => AVS_CVV_CODE[ response["CV2Result"] ]
+          :cvv_result => CVV_CODE[ response["CV2Result"] ]
         )
       end
 

data/lib/active_merchant/connection.rb

@@ -25,7 +25,7 @@ module ActiveMerchant
     attr_accessor :ca_path
     attr_accessor :pem
     attr_accessor :pem_password
-    attr_accessor :wiredump_device
+    attr_reader :wiredump_device
     attr_accessor :logger
     attr_accessor :tag
     attr_accessor :ignore_http_status
@@ -48,6 +48,11 @@ module ActiveMerchant
       @proxy_port = nil
     end
 
+    def wiredump_device=(device)
+      raise ArgumentError, "can't wiredump to frozen #{device.class}" if device && device.frozen?
+      @wiredump_device = device
+    end
+
     def request(method, body, headers = {})
       request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = "1.75.0"
+  VERSION = "1.76.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.75.0
+  version: 1.76.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-09 00:00:00.000000000 Z
+date: 2018-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -190,6 +190,7 @@ files:
 - lib/active_merchant/billing/gateways/card_save.rb
 - lib/active_merchant/billing/gateways/card_stream.rb
 - lib/active_merchant/billing/gateways/cardknox.rb
+- lib/active_merchant/billing/gateways/cardprocess.rb
 - lib/active_merchant/billing/gateways/cashnet.rb
 - lib/active_merchant/billing/gateways/cc5.rb
 - lib/active_merchant/billing/gateways/cecabank.rb
@@ -307,6 +308,7 @@ files:
 - lib/active_merchant/billing/gateways/payflow_express_uk.rb
 - lib/active_merchant/billing/gateways/payflow_uk.rb
 - lib/active_merchant/billing/gateways/payment_express.rb
+- lib/active_merchant/billing/gateways/paymentez.rb
 - lib/active_merchant/billing/gateways/paymill.rb
 - lib/active_merchant/billing/gateways/paypal.rb
 - lib/active_merchant/billing/gateways/paypal/paypal_common_api.rb