activemerchant 1.62.0 → 1.79.2

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/cashnet.rb

@@ -3,7 +3,8 @@ module ActiveMerchant #:nodoc:
     class CashnetGateway < Gateway
       include Empty
 
-      self.live_url      = "https://commerce.cashnet.com/"
+      self.live_url = "https://commerce.cashnet.com/"
+      self.test_url = "https://train.cashnet.com/"
 
       self.supported_countries = ["US"]
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
@@ -54,11 +55,22 @@ module ActiveMerchant #:nodoc:
         commit('REFUND', money, post)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript
+          .gsub(%r{(password=)[^&]+}, '\1[FILTERED]')
+          .gsub(%r{(cardno=)[^&]+}, '\1[FILTERED]')
+          .gsub(%r{(cid=)[^&]+}, '\1[FILTERED]')
+      end
+
       private
 
       def commit(action, money, fields)
         fields[:amount] = amount(money)
-        url = live_url + CGI.escape(@options[:merchant_gateway_name])
+        url = (test? ? test_url : live_url) + CGI.escape(@options[:merchant_gateway_name])
         raw_response = ssl_post(url, post_data(action, fields))
         parsed_response = parse(raw_response)
 

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

@@ -180,7 +180,7 @@ module ActiveMerchant #:nodoc:
 
       def headers
         {
-          "Accept-Encoding" => "gzip,deflate",
+          "Accept-Encoding" => "identity",
           "Content-Type"  => "text/xml;charset=UTF-8",
           "SOAPAction"  => "http://tempuri.org/Transactional/ProcessCreditCard"
         }

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

@@ -5,7 +5,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class CheckoutGateway < Gateway
       self.default_currency = 'USD'
-      self.money_format = :decimals
+      self.money_format = :cents
 
       self.supported_countries = ['AD', 'AT', 'BE', 'BG', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FO', 'FI', 'FR', 'GB', 'GI', 'GL', 'GR', 'HR', 'HU', 'IE', 'IS', 'IL', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SM', 'SK', 'SJ', 'TR', 'VA']
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]

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

@@ -4,9 +4,9 @@ module ActiveMerchant #:nodoc:
       self.display_name = "Checkout.com V2 Gateway"
       self.homepage_url = "https://www.checkout.com/"
       self.live_url = "https://api2.checkout.com/v2"
-      self.test_url = "http://sandbox.checkout.com/api2/v2"
+      self.test_url = "https://sandbox.checkout.com/api2/v2"
 
-      self.supported_countries = ['AD', 'AT', 'BE', 'BG', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FO', 'FI', 'FR', 'GB', 'GI', 'GL', 'GR', 'HR', 'HU', 'IE', 'IS', 'IL', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SM', 'SK', 'SJ', 'TR', 'VA']
+      self.supported_countries = ['AD', 'AE', 'AT', 'BE', 'BG', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FO', 'FI', 'FR', 'GB', 'GI', 'GL', 'GR', 'HR', 'HU', 'IE', 'IS', 'IL', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SM', 'SK', 'SJ', 'TR', 'VA']
       self.default_currency = "USD"
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
@@ -17,10 +17,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(amount, payment_method, options={})
-        MultiResponse.run do |r|
+        multi = MultiResponse.run do |r|
           r.process { authorize(amount, payment_method, options) }
           r.process { capture(amount, r.authorization, options) }
         end
+
+        merged_params = multi.responses.map { |r| r.params }.reduce({}, :merge)
+        succeeded = success_from(merged_params)
+
+        response(:purchase, succeeded, merged_params)
       end
 
       def authorize(amount, payment_method, options={})
@@ -29,6 +34,7 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, amount, options)
         add_payment_method(post, payment_method)
         add_customer_data(post, options)
+        add_transaction_data(post, options)
 
         commit(:authorize, post)
       end
@@ -75,7 +81,7 @@ module ActiveMerchant #:nodoc:
       private
 
       def add_invoice(post, money, options)
-        post[:value] = amount(money)
+        post[:value] = localized_amount(money, options[:currency])
         post[:trackId] = options[:order_id]
         post[:currency] = options[:currency] || currency(money)
         post[:descriptor] = {}
@@ -94,11 +100,12 @@ module ActiveMerchant #:nodoc:
 
       def add_customer_data(post, options)
         post[:email] = options[:email] || "unspecified@example.com"
+        post[:customerIp] = options[:ip] if options[:ip]
         address = options[:billing_address]
         if(address && post[:card])
           post[:card][:billingDetails] = {}
-          post[:card][:billingDetails][:address1] = address[:address1]
-          post[:card][:billingDetails][:address2] = address[:address2]
+          post[:card][:billingDetails][:addressLine1] = address[:address1]
+          post[:card][:billingDetails][:addressLine2] = address[:address2]
           post[:card][:billingDetails][:city] = address[:city]
           post[:card][:billingDetails][:state] = address[:state]
           post[:card][:billingDetails][:country] = address[:country]
@@ -107,6 +114,12 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_transaction_data(post, options={})
+        post[:cardOnFile] = true if options[:card_on_file] == true
+        post[:transactionIndicator] = options[:transaction_indicator] || 1
+        post[:previousChargeId] = options[:previous_charge_id] if options[:previous_charge_id]
+      end
+
       def commit(action, post, authorization = nil)
         begin
           raw_response = ssl_post(url(post, action, authorization), post.to_json, headers)
@@ -117,6 +130,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),
@@ -124,8 +146,9 @@ module ActiveMerchant #:nodoc:
           authorization: authorization_from(response),
           error_code: error_code_from(succeeded, response),
           test: test?,
-          avs_result: avs_result(action, response),
-          cvv_result: cvv_result(action, response))
+          avs_result: avs_result,
+          cvv_result: cvv_result
+        )
       end
 
       def headers
@@ -147,12 +170,12 @@ module ActiveMerchant #:nodoc:
         test? ? test_url : live_url
       end
 
-      def avs_result(action, response)
-        action == :purchase ? AVSResult.new(code: response["card"]["avsCheck"]) : nil
+      def avs_result(response)
+        response['card'] && response['card']['avsCheck'] ? AVSResult.new(code: response['card']['avsCheck']) : nil
       end
 
-      def cvv_result(action, response)
-        action == :purchase ? CVVResult.new(response["card"]["cvvCheck"]) : nil
+      def cvv_result(response)
+        response['card'] && response['card']['cvvCheck'] ? CVVResult.new(response['card']['cvvCheck']) : nil
       end
 
       def parse(body)
@@ -165,7 +188,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response)
-        response["responseCode"] == ("10000" || "10100")
+        (response["responseCode"] == "10000" && !response["responseMessage"].start_with?("40")) || response["responseCode"] == "10100"
       end
 
       def message_from(succeeded, response)
@@ -196,7 +219,14 @@ module ActiveMerchant #:nodoc:
       end
 
       def error_code_from(succeeded, response)
-        succeeded ? nil : STANDARD_ERROR_CODE_MAPPING[response["responseCode"]]
+        return if succeeded
+        if response["errorCode"] && response["errorMessageCodes"]
+          "#{response["errorCode"]}: #{response["errorMessageCodes"].join(", ")}"
+        elsif response["errorCode"]
+          response["errorCode"]
+        else
+          STANDARD_ERROR_CODE_MAPPING[response["responseCode"]]
+        end
       end
     end
   end

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

@@ -16,7 +16,6 @@ module ActiveMerchant
       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

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

@@ -1,5 +1,3 @@
-require 'openssl'
-
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class ClearhausGateway < Gateway

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

@@ -77,21 +77,21 @@ module ActiveMerchant #:nodoc:
         post[:description] = options[:description] || "Active Merchant Purchase"
         post[:reference_id] = options[:order_id] if options[:order_id]
         post[:currency] = (options[:currency] || currency(money)).downcase
+        post[:monthly_installments] = options[:monthly_installments] if options[:monthly_installments]
         post[:amount] = amount(money)
       end
 
       def add_details_data(post, options)
         details = {}
-        details[:name] = options[:customer] if options[:customer]
+        details[:name] = options[:customer] || (options[:billing_address][:name] if options[:billing_address])
+        details[:phone] = options[:phone] || (options[:billing_address][:phone] if options[:billing_address])
         details[:email] = options[:email] if options[:email]
-        details[:phone] = options[:phone] if options[:phone]
-        post[:device_fingerprint] = options[:device_fingerprint] if options[:device_fingerprint]
         details[:ip] = options[:ip] if options[:ip]
         add_billing_address(details, options)
         add_line_items(details, options)
         add_shipment(details, options)
-
         post[:details] = details
+        post[:device_fingerprint] = options[:device_fingerprint] if options[:device_fingerprint]
       end
 
       def add_shipment(post, options)

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

@@ -14,6 +14,32 @@ module ActiveMerchant #:nodoc:
 
       self.homepage_url = 'https://www.creditcall.com'
       self.display_name = 'Creditcall'
+      
+      CVV_CODE = {
+        "matched" => "M",
+        "notmatched" => "N",
+        "notchecked" => "P",
+        "partialmatch" => "N"
+      }
+      
+      AVS_CODE = {
+        "matched;matched" => "D",
+        "matched;notchecked" =>"B",
+        "matched;notmatched" => "A",
+        "matched;partialmatch" => "A",
+        "notchecked;matched" => "P",
+        "notchecked;notchecked" =>"I",
+        "notchecked;notmatched" => "I",
+        "notchecked;partialmatch" => "I",
+        "notmatched;matched" => "W",
+        "notmatched;notchecked" =>"C",
+        "notmatched;notmatched" => "C",
+        "notmatched;partialmatch" => "C",
+        "partialmatched;matched" => "W",
+        "partialmatched;notchecked" =>"C",
+        "partialmatched;notmatched" => "C",
+        "partialmatched;partialmatch" => "C"
+      }
 
       def initialize(options={})
         requires!(options, :terminal_id, :transaction_key)
@@ -26,11 +52,16 @@ module ActiveMerchant #:nodoc:
           r.process { capture(money, r.authorization, options) }
         end
 
+        merged_params = multi_response.responses.map { |r| r.params }.reduce({}, :merge)
+        
         Response.new(
           multi_response.primary_response.success?,
           multi_response.primary_response.message,
-          multi_response.primary_response.params,
+          merged_params,
           authorization: multi_response.responses.first.authorization,
+          avs_result: AVSResult.new(code: avs_result_code_from(merged_params)),
+          cvv_result: CVVResult.new(cvv_result_code_from(merged_params)),
+          error_code: error_result_code_from(merged_params),
           test: test?
         )
       end
@@ -92,6 +123,18 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def avs_result_code_from(params)
+        AVS_CODE["#{params['Address']};#{params['Zip']}"]
+      end
+
+      def cvv_result_code_from(params)
+        CVV_CODE[params["CSC"]]
+      end
+
+      def error_result_code_from(params)
+        params["ErrorCode"]
+      end
+
       def build_xml_request
         builder = Nokogiri::XML::Builder.new do |xml|
           xml.Request(type: "CardEaseXML", version: "1.0.0") do
@@ -120,17 +163,22 @@ module ActiveMerchant #:nodoc:
 
       def add_card_details(xml, payment_method, options={})
         xml.CardDetails do
-          xml.Manual(type: "ecommerce") do
+          xml.Manual(type: manual_type(options)) do
             xml.PAN payment_method.number
             xml.ExpiryDate exp_date(payment_method)
             xml.CSC payment_method.verification_value unless empty?(payment_method.verification_value)
           end
 
-          if address = options[:billing_address]
-            xml.AdditionalVerification do
-              xml.Address address[:address1]
-              xml.Zip address[:zip]
-            end
+          add_additional_verification(xml, options)
+        end
+      end
+
+      def add_additional_verification(xml, options)
+        return unless (options[:verify_zip].to_s == 'true') || (options[:verify_address].to_s == 'true')
+        if address = options[:billing_address]
+          xml.AdditionalVerification do
+            xml.Zip address[:zip] if options[:verify_zip].to_s  == 'true'
+            xml.Address address[:address1] if options[:verify_address].to_s  == 'true'
           end
         end
       end
@@ -157,6 +205,16 @@ module ActiveMerchant #:nodoc:
           end
         end
 
+        node = xml.xpath("//Response/CardDetails")
+        node.children.each do |childnode|
+          if childnode.elements.empty?
+            response[childnode.name] = childnode.text
+          else
+            childnode_to_response(response, childnode)
+          end
+        end
+
+
         response
       end
 
@@ -179,8 +237,9 @@ module ActiveMerchant #:nodoc:
           message_from(response),
           response,
           authorization: authorization_from(response),
-          avs_result: AVSResult.new(code: response["some_avs_response_key"]),
-          cvv_result: CVVResult.new(response["some_cvv_response_key"]),
+          avs_result: AVSResult.new(code: avs_result_code_from(response)),
+          cvv_result: CVVResult.new(cvv_result_code_from(response)),
+          error_code: error_result_code_from(response),
           test: test?
         )
       end
@@ -205,6 +264,9 @@ module ActiveMerchant #:nodoc:
         response["CardEaseReference"]
       end
 
+      def manual_type(options)
+        options[:manual_type] ? options[:manual_type] : "ecommerce"
+      end
     end
   end
 end