activemerchant 1.45.0 → 1.126.0

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

@@ -3,15 +3,15 @@ require 'json'
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class EwayRapidGateway < Gateway
-      self.test_url = "https://api.sandbox.ewaypayments.com/"
-      self.live_url = "https://api.ewaypayments.com/"
+      self.test_url = 'https://api.sandbox.ewaypayments.com/'
+      self.live_url = 'https://api.ewaypayments.com/'
 
       self.money_format = :cents
-      self.supported_countries = ['AU', 'NZ', 'GB']
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
-      self.homepage_url = "http://www.eway.com.au/"
-      self.display_name = "eWAY Rapid 3.1"
-      self.default_currency = "AUD"
+      self.supported_countries = %w[AU NZ GB SG MY HK]
+      self.supported_cardtypes = %i[visa master american_express diners_club jcb]
+      self.homepage_url = 'http://www.eway.com.au/'
+      self.display_name = 'eWAY Rapid 3.1'
+      self.default_currency = 'AUD'
 
       class_attribute :partner_id
 
@@ -28,6 +28,8 @@ module ActiveMerchant #:nodoc:
       #                  :transaction_type - One of: Purchase (default), MOTO
       #                                      or Recurring.  For stored card payments (aka - TokenPayments),
       #                                      this must be either MOTO or Recurring.
+      #                  :invoice          - The merchant’s invoice number for this
+      #                                      transaction (optional).
       #                  :order_id         - A merchant-supplied identifier for the
       #                                      transaction (optional).
       #                  :description      - A merchant-supplied description of the
@@ -42,24 +44,25 @@ module ActiveMerchant #:nodoc:
       #                                      transaction (optional).
       #                  :application_id   - A string identifying the application
       #                                      submitting the transaction
-      #                                      (default: "https://github.com/Shopify/active_merchant")
+      #                                      (default: "https://github.com/activemerchant/active_merchant")
       #
       # Returns an ActiveMerchant::Billing::Response object where authorization is the Transaction ID on success
-      def purchase(amount, payment_method, options={})
+      def purchase(amount, payment_method, options = {})
         params = {}
         add_metadata(params, options)
         add_invoice(params, amount, options)
-        add_customer_data(params, options)
+        add_customer_data(params, options, payment_method)
         add_credit_card(params, payment_method, options)
+        add_3ds_authenticated_data(params, options) if options[:three_d_secure]
         params['Method'] = payment_method.respond_to?(:number) ? 'ProcessPayment' : 'TokenPayment'
         commit(url_for('Transaction'), params)
       end
 
-      def authorize(amount, payment_method, options={})
+      def authorize(amount, payment_method, options = {})
         params = {}
         add_metadata(params, options)
         add_invoice(params, amount, options)
-        add_customer_data(params, options)
+        add_customer_data(params, options, payment_method)
         add_credit_card(params, payment_method, options)
         params['Method'] = 'Authorise'
         commit(url_for('Authorisation'), params)
@@ -70,13 +73,13 @@ module ActiveMerchant #:nodoc:
         add_metadata(params, options)
         add_invoice(params, amount, options)
         add_reference(params, identification)
-        commit(url_for("CapturePayment"), params)
+        commit(url_for('CapturePayment'), params)
       end
 
       def void(identification, options = {})
         params = {}
         add_reference(params, identification)
-        commit(url_for("CancelAuthorisation"), params)
+        commit(url_for('CancelAuthorisation'), params)
       end
 
       # Public: Refund a transaction.
@@ -85,6 +88,8 @@ module ActiveMerchant #:nodoc:
       # identification - The transaction id which is returned in the
       #                  authorization of the successful purchase transaction
       # options        - A standard ActiveMerchant options hash:
+      #                  :invoice          - The merchant’s invoice number for this
+      #                                      transaction (optional).
       #                  :order_id         - A merchant-supplied identifier for the
       #                                      transaction (optional).
       #                  :description      - A merchant-supplied description of the
@@ -99,14 +104,14 @@ module ActiveMerchant #:nodoc:
       #                                      transaction (optional).
       #                  :application_id   - A string identifying the application
       #                                      submitting the transaction
-      #                                      (default: "https://github.com/Shopify/active_merchant")
+      #                                      (default: "https://github.com/activemerchant/active_merchant")
       #
       # Returns an ActiveMerchant::Billing::Response object
       def refund(amount, identification, options = {})
         params = {}
         add_metadata(params, options)
-        add_invoice(params, amount, options, "Refund")
-        add_reference(params["Refund"], identification)
+        add_invoice(params, amount, options, 'Refund')
+        add_reference(params['Refund'], identification)
         add_customer_data(params, options)
         commit(url_for("Transaction/#{identification}/Refund"), params)
       end
@@ -125,7 +130,7 @@ module ActiveMerchant #:nodoc:
       #                                      transaction (optional).
       #                  :application_id   - A string identifying the application
       #                                      submitting the transaction
-      #                                      (default: "https://github.com/Shopify/active_merchant")
+      #                                      (default: "https://github.com/activemerchant/active_merchant")
       #
       # Returns an ActiveMerchant::Billing::Response object where the authorization is the customer_token on success
       def store(payment_method, options = {})
@@ -133,10 +138,10 @@ module ActiveMerchant #:nodoc:
         params = {}
         add_metadata(params, options)
         add_invoice(params, 0, options)
-        add_customer_data(params, options)
+        add_customer_data(params, options, payment_method)
         add_credit_card(params, payment_method, options)
         params['Method'] = 'CreateTokenCustomer'
-        commit(url_for("Transaction"), params)
+        commit(url_for('Transaction'), params)
       end
 
       # Public: Update a customer's data
@@ -155,18 +160,29 @@ module ActiveMerchant #:nodoc:
       #                                      transaction (optional).
       #                  :application_id   - A string identifying the application
       #                                      submitting the transaction
-      #                                      (default: "https://github.com/Shopify/active_merchant")
+      #                                      (default: "https://github.com/activemerchant/active_merchant")
       #
       # Returns an ActiveMerchant::Billing::Response object where the authorization is the customer_token on success
       def update(customer_token, payment_method, options = {})
         params = {}
         add_metadata(params, options)
         add_invoice(params, 0, options)
-        add_customer_data(params, options)
+        add_customer_data(params, options, payment_method)
         add_credit_card(params, payment_method, options)
         add_customer_token(params, customer_token)
         params['Method'] = 'UpdateTokenCustomer'
-        commit(url_for("Transaction"), params)
+        commit(url_for('Transaction'), params)
+      end
+
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r(("Number\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("CVN\\?":\\?"?)[^",]*)i, '\1[FILTERED]')
       end
 
       private
@@ -182,13 +198,26 @@ module ActiveMerchant #:nodoc:
         params
       end
 
-      def add_invoice(params, money, options, key = "Payment")
+      def add_3ds_authenticated_data(params, options)
+        three_d_secure_options = options[:three_d_secure]
+        params['PaymentInstrument'] ||= {} if params['PaymentInstrument'].nil?
+        threed_secure_auth = params['PaymentInstrument']['ThreeDSecureAuth'] = {}
+        threed_secure_auth['Cryptogram'] = three_d_secure_options[:cavv]
+        threed_secure_auth['ECI'] = three_d_secure_options[:eci]
+        threed_secure_auth['XID'] = three_d_secure_options[:xid]
+        threed_secure_auth['AuthStatus'] = three_d_secure_options[:authentication_response_status]
+        threed_secure_auth['dsTransactionId'] = three_d_secure_options[:ds_transaction_id]
+        threed_secure_auth['Version'] = three_d_secure_options[:version]
+      end
+
+      def add_invoice(params, money, options, key = 'Payment')
         currency_code = options[:currency] || currency(money)
         params[key] = {
           'TotalAmount' => localized_amount(money, currency_code),
-          'InvoiceReference' => truncate(options[:order_id]),
+          'InvoiceReference' => truncate(options[:order_id], 50),
+          'InvoiceNumber' => truncate(options[:invoice] || options[:order_id], 12),
           'InvoiceDescription' => truncate(options[:description], 64),
-          'CurrencyCode' => currency_code,
+          'CurrencyCode' => currency_code
         }
       end
 
@@ -196,43 +225,70 @@ module ActiveMerchant #:nodoc:
         params['TransactionID'] = reference
       end
 
-      def add_customer_data(params, options)
-        params['Customer'] ||= {}
-        add_address(params['Customer'], (options[:billing_address] || options[:address]), {:email => options[:email]})
-        params['ShippingAddress'] = {}
-        add_address(params['ShippingAddress'], options[:shipping_address], {:skip_company => true})
+      def add_customer_data(params, options, payment_method = nil)
+        add_customer_fields(params, options, payment_method)
+        add_shipping_fields(params, options)
       end
 
-      def add_address(params, address, options={})
-        return unless address
+      def add_customer_fields(params, options, payment_method)
+        key = 'Customer'
+        params[key] ||= {}
+
+        customer_address = options[:billing_address] || options[:address]
 
-        if address[:name]
-          parts = address[:name].split(/\s+/)
-          params['FirstName'] = parts.shift if parts.size > 1
-          params['LastName'] = parts.join(" ")
+        add_name_and_email(params[key], customer_address, options[:email], payment_method)
+        add_address(params[key], customer_address)
+      end
+
+      def add_shipping_fields(params, options)
+        key = 'ShippingAddress'
+        params[key] = {}
+
+        add_name_and_email(params[key], options[:shipping_address], options[:email])
+        add_address(params[key], options[:shipping_address], { skip_company: true })
+      end
+
+      def add_name_and_email(params, address, email, payment_method = nil)
+        if address.present?
+          params['FirstName'], params['LastName'] = split_names(address[:name])
+        elsif payment_method_name_available?(payment_method)
+          params['FirstName'] = payment_method.first_name
+          params['LastName'] = payment_method.last_name
         end
+
+        params['Email'] = email
+      end
+
+      def payment_method_name_available?(payment_method)
+        payment_method.respond_to?(:first_name) && payment_method.respond_to?(:last_name) &&
+          payment_method.first_name.present? && payment_method.last_name.present?
+      end
+
+      def add_address(params, address, options = {})
+        return unless address
+
         params['Title'] = address[:title]
         params['CompanyName'] = address[:company] unless options[:skip_company]
-        params['Street1'] = truncate(address[:address1])
-        params['Street2'] = truncate(address[:address2])
-        params['City'] = truncate(address[:city])
+        params['Street1'] = truncate(address[:address1], 50)
+        params['Street2'] = truncate(address[:address2], 50)
+        params['City'] = truncate(address[:city], 50)
         params['State'] = address[:state]
         params['PostalCode'] = address[:zip]
         params['Country'] = address[:country].to_s.downcase
-        params['Phone'] = address[:phone]
+        params['Phone'] = address[:phone] || address[:phone_number]
         params['Fax'] = address[:fax]
-        params['Email'] = options[:email]
       end
 
       def add_credit_card(params, credit_card, options)
         return unless credit_card
+
         params['Customer'] ||= {}
         if credit_card.respond_to? :number
           card_details = params['Customer']['CardDetails'] = {}
-          card_details['Name'] = truncate(credit_card.name)
+          card_details['Name'] = truncate(credit_card.name, 50)
           card_details['Number'] = credit_card.number
-          card_details['ExpiryMonth'] = "%02d" % (credit_card.month || 0)
-          card_details['ExpiryYear'] = "%02d" % (credit_card.year || 0)
+          card_details['ExpiryMonth'] = '%02d' % (credit_card.month || 0)
+          card_details['ExpiryYear'] = '%02d' % (credit_card.year || 0)
           card_details['CVN'] = credit_card.verification_value
         else
           add_customer_token(params, credit_card)
@@ -250,8 +306,8 @@ module ActiveMerchant #:nodoc:
 
       def commit(url, params)
         headers = {
-          "Authorization" => ("Basic " + Base64.strict_encode64(@options[:login].to_s + ":" + @options[:password].to_s).chomp),
-          "Content-Type" => "application/json"
+          'Authorization' => ('Basic ' + Base64.strict_encode64(@options[:login].to_s + ':' + @options[:password].to_s).chomp),
+          'Content-Type' => 'application/json'
         }
         request = params.to_json
         raw = parse(ssl_post(url, request, headers))
@@ -261,13 +317,13 @@ module ActiveMerchant #:nodoc:
           succeeded,
           message_from(succeeded, raw),
           raw,
-          :authorization => authorization_from(raw),
-          :test => test?,
-          :avs_result => avs_result_from(raw),
-          :cvv_result => cvv_result_from(raw)
+          authorization: authorization_from(raw),
+          test: test?,
+          avs_result: avs_result_from(raw),
+          cvv_result: cvv_result_from(raw)
         )
       rescue ActiveMerchant::ResponseError => e
-        return ActiveMerchant::Billing::Response.new(false, e.response.message, {:status_code => e.response.code}, :test => test?)
+        return ActiveMerchant::Billing::Response.new(false, e.response.message, { status_code: e.response.code }, test: test?)
       end
 
       def parse(data)
@@ -275,19 +331,19 @@ module ActiveMerchant #:nodoc:
       end
 
       def success?(response)
-        if response['ResponseCode'] == "00"
+        if response['ResponseCode'] == '00'
           true
         elsif response['TransactionStatus']
           (response['TransactionStatus'] == true)
-        elsif response["Succeeded"]
-          (response["Succeeded"] == true)
+        elsif response['Succeeded']
+          (response['Succeeded'] == true)
         else
           false
         end
       end
 
       def parse_errors(message)
-        errors = message.split(',').collect{|code| MESSAGES[code.strip]}.flatten.join(',')
+        errors = message.split(',').collect { |code| MESSAGES[code.strip] }.flatten.join(',')
         errors.presence || message
       end
 
@@ -299,48 +355,44 @@ module ActiveMerchant #:nodoc:
         elsif response['ResponseCode']
           ActiveMerchant::Billing::EwayGateway::MESSAGES[response['ResponseCode']]
         elsif succeeded
-          "Succeeded"
+          'Succeeded'
         else
-          "Failed"
+          'Failed'
         end
       end
 
       def authorization_from(response)
         # Note: TransactionID is always null for store requests, but TokenCustomerID is also sent back for purchase from
-        # stored card transactions so we give precendence to TransactionID
+        # stored card transactions so we give precedence to TransactionID
         response['TransactionID'] || response['Customer']['TokenCustomerID']
       end
 
       def avs_result_from(response)
         verification = response['Verification'] || {}
-        code = case verification['Address']
-        when "Valid"
-          "M"
-        when "Invalid"
-          "N"
-        else
-          "I"
-        end
-        {:code => code}
+        code =
+          case verification['Address']
+          when 'Valid'
+            'M'
+          when 'Invalid'
+            'N'
+          else
+            'I'
+          end
+        { code: code }
       end
 
       def cvv_result_from(response)
         verification = response['Verification'] || {}
         case verification['CVN']
-        when "Valid"
-          "M"
-        when "Invalid"
-          "N"
+        when 'Valid'
+          'M'
+        when 'Invalid'
+          'N'
         else
-          "P"
+          'P'
         end
       end
 
-      def truncate(value, max_size = 50)
-        return nil unless value
-        value.to_s[0, max_size]
-      end
-
       MESSAGES = {
         'A2000' => 'Transaction Approved Successful',
         'A2008' => 'Honour With Identification Successful',
@@ -352,7 +404,7 @@ module ActiveMerchant #:nodoc:
         'D4403' => 'No Merchant Failed',
         'D4404' => 'Pick Up Card  Failed',
         'D4405' => 'Do Not Honour Failed',
-        'D4406' => 'Error   Failed',
+        'D4406' => 'Error Failed',
         'D4407' => 'Pick Up Card, Special Failed',
         'D4409' => 'Request In Progress Failed',
         'D4412' => 'Invalid Transaction Failed',
@@ -406,6 +458,8 @@ module ActiveMerchant #:nodoc:
         'D4498' => 'PayPal Create Transaction Error Failed',
         'D4499' => 'Invalid Transaction for Auth/Void Failed',
         'S5000' => 'System Error',
+        'S5011' => 'PayPal Connection Error',
+        'S5012' => 'PayPal Settings Error',
         'S5085' => 'Started 3dSecure',
         'S5086' => 'Routed 3dSecure',
         'S5087' => 'Completed 3dSecure',
@@ -517,7 +571,7 @@ module ActiveMerchant #:nodoc:
         'V6150' => 'Invalid Refund Amount',
         'V6151' => 'Refund amount greater than original transaction',
         'V6152' => 'Original transaction already refunded for total amount',
-        'V6153' => 'Card type not support by merchant',
+        'V6153' => 'Card type not support by merchant'
       }
     end
   end

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

@@ -3,40 +3,35 @@ module ActiveMerchant #:nodoc:
     class ExactGateway < Gateway
       self.live_url = self.test_url = 'https://secure2.e-xact.com/vplug-in/transaction/rpc-enc/service.asmx'
 
-      API_VERSION = "8.5"
+      API_VERSION = '8.5'
 
-      TEST_LOGINS = [ {:login => "A00049-01", :password => "test1"},
-                      {:login => "A00427-01", :password => "testus"} ]
-
-      TRANSACTIONS = { :sale          => "00",
-                       :authorization => "01",
-                       :capture       => "32",
-                       :credit        => "34" }
+      TEST_LOGINS = [{ login: 'A00049-01', password: 'test1' },
+                     { login: 'A00427-01', password: 'testus' }]
 
+      TRANSACTIONS = { sale: '00',
+                       authorization: '01',
+                       capture: '32',
+                       credit: '34' }
 
       ENVELOPE_NAMESPACES = { 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
                               'xmlns:env' => 'http://schemas.xmlsoap.org/soap/envelope/',
-                              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
-                            }
+                              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance' }
 
-      SEND_AND_COMMIT_ATTRIBUTES = { 'xmlns:n1' => "http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/Request",
-                                     'env:encodingStyle' => 'http://schemas.xmlsoap.org/soap/encoding/'
-                                   }
+      SEND_AND_COMMIT_ATTRIBUTES = { 'xmlns:n1' => 'http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/Request',
+                                     'env:encodingStyle' => 'http://schemas.xmlsoap.org/soap/encoding/' }
 
       SEND_AND_COMMIT_SOURCE_ATTRIBUTES = { 'xmlns:n2' => 'http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/encodedTypes',
-                                            'xsi:type' => 'n2:Transaction'
-                                          }
+                                            'xsi:type' => 'n2:Transaction' }
 
-      POST_HEADERS = { 'soapAction' => "http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/SendAndCommit",
-                       'Content-Type' => 'text/xml'
-                     }
+      POST_HEADERS = { 'soapAction' => 'http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/SendAndCommit',
+                       'Content-Type' => 'text/xml' }
 
-      SUCCESS = "true"
+      SUCCESS = 'true'
 
-      SENSITIVE_FIELDS = [ :verification_str2, :expiry_date, :card_number ]
+      SENSITIVE_FIELDS = %i[verification_str2 expiry_date card_number]
 
-      self.supported_cardtypes = [:visa, :master, :american_express, :jcb, :discover]
-      self.supported_countries = ['CA', 'US']
+      self.supported_countries = %w[CA US]
+      self.supported_cardtypes = %i[visa master american_express jcb discover]
       self.homepage_url = 'http://www.e-xact.com'
       self.display_name = 'E-xact'
 
@@ -68,6 +63,7 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+
       def build_request(action, body)
         xml = Builder::XmlMarkup.new
 
@@ -160,14 +156,20 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, request)
-         response = parse(ssl_post(self.live_url, build_request(action, request), POST_HEADERS))
-
-         Response.new(successful?(response), message_from(response), response,
-           :test => test?,
-           :authorization => authorization_from(response),
-           :avs_result => { :code => response[:avs] },
-           :cvv_result => response[:cvv2]
-         )
+        response = parse(ssl_post(self.live_url, build_request(action, request), POST_HEADERS))
+
+        Response.new(successful?(response), message_from(response), response,
+          test: test?,
+          authorization: authorization_from(response),
+          avs_result: { code: response[:avs] },
+          cvv_result: response[:cvv2])
+      rescue ResponseError => e
+        case e.response.code
+        when '401'
+          return Response.new(false, "Invalid Login: #{e.response.body}", {}, test: test?)
+        else
+          raise
+        end
       end
 
       def successful?(response)
@@ -176,9 +178,9 @@ module ActiveMerchant #:nodoc:
 
       def authorization_from(response)
         if response[:authorization_num] && response[:transaction_tag]
-           "#{response[:authorization_num]};#{response[:transaction_tag]}"
+          "#{response[:authorization_num]};#{response[:transaction_tag]}"
         else
-           ''
+          ''
         end
       end
 
@@ -198,13 +200,13 @@ module ActiveMerchant #:nodoc:
         response = {}
         xml = REXML::Document.new(xml)
 
-        if root = REXML::XPath.first(xml, "//types:TransactionResult")
+        if root = REXML::XPath.first(xml, '//types:TransactionResult')
           parse_elements(response, root)
-        elsif root = REXML::XPath.first(xml, "//soap:Fault")
+        elsif root = REXML::XPath.first(xml, '//soap:Fault')
           parse_elements(response, root)
         end
 
-        response.delete_if{ |k,v| SENSITIVE_FIELDS.include?(k) }
+        response.delete_if { |k, _v| SENSITIVE_FIELDS.include?(k) }
       end
 
       def parse_elements(response, root)
@@ -215,4 +217,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-