activemerchant 1.79.2 → 1.129.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', 'SG', 'MY', 'HK']
-      self.supported_cardtypes = [: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"
+      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
 
@@ -47,21 +47,22 @@ module ActiveMerchant #:nodoc:
       #                                      (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)
@@ -72,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.
@@ -109,8 +110,8 @@ module ActiveMerchant #:nodoc:
       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
@@ -137,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
@@ -166,11 +167,11 @@ 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)
         add_customer_token(params, customer_token)
         params['Method'] = 'UpdateTokenCustomer'
-        commit(url_for("Transaction"), params)
+        commit(url_for('Transaction'), params)
       end
 
       def supports_scrubbing
@@ -197,14 +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], 50),
           'InvoiceNumber' => truncate(options[:invoice] || options[:order_id], 12),
           'InvoiceDescription' => truncate(options[:description], 64),
-          'CurrencyCode' => currency_code,
+          'CurrencyCode' => currency_code
         }
       end
 
@@ -212,17 +225,48 @@ 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_customer_fields(params, options, payment_method)
+        key = 'Customer'
+        params[key] ||= {}
+
+        customer_address = options[:billing_address] || options[:address]
+
+        add_name_and_email(params[key], customer_address, options[:email], payment_method)
+        add_address(params[key], customer_address)
       end
 
-      def add_address(params, address, options={})
+      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['FirstName'], params['LastName'] = split_names(address[:name])
         params['Title'] = address[:title]
         params['CompanyName'] = address[:company] unless options[:skip_company]
         params['Street1'] = truncate(address[:address1], 50)
@@ -231,20 +275,20 @@ module ActiveMerchant #:nodoc:
         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, 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)
@@ -262,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))
@@ -273,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)
@@ -287,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
 
@@ -311,9 +355,9 @@ module ActiveMerchant #:nodoc:
         elsif response['ResponseCode']
           ActiveMerchant::Billing::EwayGateway::MESSAGES[response['ResponseCode']]
         elsif succeeded
-          "Succeeded"
+          'Succeeded'
         else
-          "Failed"
+          'Failed'
         end
       end
 
@@ -325,26 +369,27 @@ module ActiveMerchant #:nodoc:
 
       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
 
@@ -526,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'
 
@@ -161,19 +156,17 @@ 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?)
+          return Response.new(false, "Invalid Login: #{e.response.body}", {}, test: test?)
         else
           raise
         end
@@ -185,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
 
@@ -207,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)
@@ -224,4 +217,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -5,17 +5,17 @@ module ActiveMerchant
 
       self.supported_countries = %w(AU CA CN FR DE GI IL MT MU MX NL NZ PA PH RU SG KR ES KN GB US)
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+      self.supported_cardtypes = %i[visa master american_express discover jcb diners_club]
 
       self.homepage_url = 'http://www.ezic.com/'
       self.display_name = 'Ezic'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :account_id)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = {}
 
         add_account_id(post)
@@ -23,10 +23,10 @@ module ActiveMerchant
         add_payment(post, payment)
         add_customer_data(post, options)
 
-        commit("S", post)
+        commit('S', post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = {}
 
         add_account_id(post)
@@ -34,10 +34,10 @@ module ActiveMerchant
         add_payment(post, payment)
         add_customer_data(post, options)
 
-        commit("A", post)
+        commit('A', post)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
 
         add_account_id(post)
@@ -45,10 +45,10 @@ module ActiveMerchant
         add_authorization(post, authorization)
         add_pay_type(post)
 
-        commit("D", post)
+        commit('D', post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
 
         add_account_id(post)
@@ -56,20 +56,20 @@ module ActiveMerchant
         add_authorization(post, authorization)
         add_pay_type(post)
 
-        commit("R", post)
+        commit('R', post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
 
         add_account_id(post)
         add_authorization(post, authorization)
         add_pay_type(post)
 
-        commit("U", post)
+        commit('U', post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -143,7 +143,7 @@ module ActiveMerchant
       end
 
       def add_pay_type(post)
-        post[:pay_type] = "C"
+        post[:pay_type] = 'C'
       end
 
       def parse(body)
@@ -160,8 +160,8 @@ module ActiveMerchant
             message_from(response),
             response,
             authorization: authorization_from(response),
-            avs_result: AVSResult.new(code: response["avs_code"]),
-            cvv_result: CVVResult.new(response["cvv2_code"]),
+            avs_result: AVSResult.new(code: response['avs_code']),
+            cvv_result: CVVResult.new(response['cvv2_code']),
             test: test?
           )
         rescue ResponseError => e
@@ -170,27 +170,26 @@ module ActiveMerchant
       end
 
       def success_from(response)
-        response["status_code"] == "1" || response["status_code"] == "T"
+        response['status_code'] == '1' || response['status_code'] == 'T'
       end
 
       def message_from(response)
-        response["auth_msg"]
+        response['auth_msg']
       end
 
       def authorization_from(response)
-        response["trans_id"]
+        response['trans_id']
       end
 
       def post_data(parameters = {})
-        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def headers
         {
-          "User-Agent" => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'User-Agent' => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
         }
       end
     end
-
   end
 end