activemerchant 1.38.0 → 1.79.2

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

@@ -0,0 +1,356 @@
+require 'nokogiri'
+require 'securerandom'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class ElementGateway < Gateway
+      self.test_url = 'https://certtransaction.elementexpress.com/express.asmx'
+      self.live_url = 'https://transaction.elementexpress.com/express.asmx'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+      self.homepage_url = 'http://www.elementps.com'
+      self.display_name = 'Element'
+
+      SERVICE_TEST_URL = 'https://certservices.elementexpress.com/express.asmx'
+      SERVICE_LIVE_URL = 'https://services.elementexpress.com/express.asmx'
+
+      def initialize(options={})
+        requires!(options, :account_id, :account_token, :application_id, :acceptor_id, :application_name, :application_version)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        action = payment.is_a?(Check) ? "CheckSale" : "CreditCardSale"
+
+        request = build_soap_request do |xml|
+          xml.send(action, xmlns: "https://transaction.elementexpress.com") do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_transaction(xml, money, options)
+            add_terminal(xml, options)
+            add_address(xml, options)
+          end
+        end
+
+        commit(action, request, money)
+      end
+
+      def authorize(money, payment, options={})
+        request = build_soap_request do |xml|
+          xml.CreditCardAuthorization(xmlns: "https://transaction.elementexpress.com") do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_transaction(xml, money, options)
+            add_terminal(xml, options)
+            add_address(xml, options)
+          end
+        end
+
+        commit('CreditCardAuthorization', request, money)
+      end
+
+      def capture(money, authorization, options={})
+        trans_id, _ = split_authorization(authorization)
+        options.merge!({trans_id: trans_id})
+
+        request = build_soap_request do |xml|
+          xml.CreditCardAuthorizationCompletion(xmlns: "https://transaction.elementexpress.com") do
+            add_credentials(xml)
+            add_transaction(xml, money, options)
+            add_terminal(xml, options)
+          end
+        end
+
+        commit('CreditCardAuthorizationCompletion', request, money)
+      end
+
+      def refund(money, authorization, options={})
+        trans_id, _ = split_authorization(authorization)
+        options.merge!({trans_id: trans_id})
+
+        request = build_soap_request do |xml|
+          xml.CreditCardReturn(xmlns: "https://transaction.elementexpress.com") do
+            add_credentials(xml)
+            add_transaction(xml, money, options)
+            add_terminal(xml, options)
+          end
+        end
+
+        commit('CreditCardReturn', request, money)
+      end
+
+      def void(authorization, options={})
+        trans_id, trans_amount = split_authorization(authorization)
+        options.merge!({trans_id: trans_id, trans_amount: trans_amount, reversal_type: "Full"})
+
+        request = build_soap_request do |xml|
+          xml.CreditCardReversal(xmlns: "https://transaction.elementexpress.com") do
+            add_credentials(xml)
+            add_transaction(xml, trans_amount, options)
+            add_terminal(xml, options)
+          end
+        end
+
+        commit('CreditCardReversal', request, trans_amount)
+      end
+
+      def store(payment, options = {})
+        request = build_soap_request do |xml|
+          xml.PaymentAccountCreate(xmlns: "https://services.elementexpress.com") do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_payment_account(xml, payment, options[:payment_account_reference_number] || SecureRandom.hex(20))
+            add_address(xml, options)
+          end
+        end
+
+        commit('PaymentAccountCreate', request, nil)
+      end
+
+      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) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<AccountToken>).+?(</AccountToken>))i, '\1[FILTERED]\2').
+          gsub(%r((<CardNumber>).+?(</CardNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<CVV>).+?(</CVV>))i, '\1[FILTERED]\2').
+          gsub(%r((<AccountNumber>).+?(</AccountNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<RoutingNumber>).+?(</RoutingNumber>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_credentials(xml)
+        xml.credentials do
+          xml.AccountID @options[:account_id]
+          xml.AccountToken @options[:account_token]
+          xml.AcceptorID @options[:acceptor_id]
+        end
+        xml.application do
+          xml.ApplicationID @options[:application_id]
+          xml.ApplicationName @options[:application_name]
+          xml.ApplicationVersion @options[:application_version]
+        end
+      end
+
+      def add_payment_method(xml, payment)
+        if payment.is_a?(String)
+          add_payment_account_id(xml, payment)
+        elsif payment.is_a?(Check)
+          add_echeck(xml, payment)
+        else
+          add_credit_card(xml, payment)
+        end
+      end
+
+      def add_payment_account(xml, payment, payment_account_reference_number)
+        xml.paymentAccount do
+          xml.PaymentAccountType payment_account_type(payment)
+          xml.PaymentAccountReferenceNumber payment_account_reference_number
+        end
+      end
+
+      def add_payment_account_id(xml, payment)
+        xml.extendedParameters do
+          xml.ExtendedParameters do
+            xml.Key "PaymentAccount"
+            xml.Value("xsi:type" => "PaymentAccount") do
+              xml.PaymentAccountID payment
+            end
+          end
+        end
+      end
+
+      def add_transaction(xml, money, options = {})
+        xml.transaction do
+          xml.ReversalType options[:reversal_type] if options[:reversal_type]
+          xml.TransactionID options[:trans_id] if options[:trans_id]
+          xml.TransactionAmount amount(money.to_i) if money
+          xml.MarketCode "Default" if money
+          xml.ReferenceNumber options[:order_id] || SecureRandom.hex(20)
+        end
+      end
+
+      def add_terminal(xml, options)
+        xml.terminal do
+          xml.TerminalID "01"
+          xml.CardPresentCode "UseDefault"
+          xml.CardholderPresentCode "UseDefault"
+          xml.CardInputCode "UseDefault"
+          xml.CVVPresenceCode "UseDefault"
+          xml.TerminalCapabilityCode "UseDefault"
+          xml.TerminalEnvironmentCode "UseDefault"
+          xml.MotoECICode "NonAuthenticatedSecureECommerceTransaction"
+        end
+      end
+
+      def add_credit_card(xml, payment)
+        xml.card do
+          xml.CardNumber payment.number
+          xml.ExpirationMonth format(payment.month, :two_digits)
+          xml.ExpirationYear format(payment.year, :two_digits)
+          xml.CardholderName payment.first_name + " " + payment.last_name
+          xml.CVV payment.verification_value
+        end
+      end
+
+      def add_echeck(xml, payment)
+        xml.demandDepositAccount do
+          xml.AccountNumber payment.account_number
+          xml.RoutingNumber payment.routing_number
+          xml.DDAAccountType payment.account_type.capitalize
+        end
+      end
+
+      def add_address(xml, options)
+        if address = options[:billing_address] || options[:address]
+          xml.address do
+            xml.BillingAddress1 address[:address1] if address[:address1]
+            xml.BillingAddress2 address[:address2] if address[:address2]
+            xml.BillingCity address[:city] if address[:city]
+            xml.BillingState address[:state] if address[:state]
+            xml.BillingZipcode address[:zip] if address[:zip]
+            xml.BillingEmail address[:email] if address[:email]
+            xml.BillingPhone address[:phone_number] if address[:phone_number]
+          end
+        end
+        if shipping_address = options[:shipping_address]
+          xml.address do
+            xml.ShippingAddress1 shipping_address[:address1] if shipping_address[:address1]
+            xml.ShippingAddress2 shipping_address[:address2] if shipping_address[:address2]
+            xml.ShippingCity shipping_address[:city] if shipping_address[:city]
+            xml.ShippingState shipping_address[:state] if shipping_address[:state]
+            xml.ShippingZipcode shipping_address[:zip] if shipping_address[:zip]
+            xml.ShippingEmail shipping_address[:email] if shipping_address[:email]
+            xml.ShippingPhone shipping_address[:phone_number] if shipping_address[:phone_number]
+          end
+        end
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.remove_namespaces!
+        root = doc.root.xpath("//response/*")
+
+        if root.empty?
+          root = doc.root.xpath("//Response/*")
+        end
+
+        root.each do |node|
+          if (node.elements.empty?)
+            response[node.name.downcase] = node.text
+          else
+            node_name = node.name.downcase
+            response[node_name] = Hash.new
+
+            node.elements.each do |childnode|
+              response[node_name][childnode.name.downcase] = childnode.text
+            end
+          end
+        end
+
+        response
+      end
+
+      def commit(action, xml, amount)
+        response = parse(ssl_post(url(action), xml, headers(action)))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(action, response, amount),
+          avs_result: success_from(response) ? avs_from(response) : nil,
+          cvv_result: success_from(response) ? cvv_from(response) : nil,
+          test: test?
+        )
+      end
+
+      def authorization_from(action, response, amount)
+        if action == "PaymentAccountCreate"
+          response["paymentaccount"]["paymentaccountid"]
+        else
+          "#{response['transaction']['transactionid']}|#{amount}" if response['transaction']
+        end
+      end
+
+      def success_from(response)
+        response["expressresponsecode"] == "0"
+      end
+
+      def message_from(response)
+        response["expressresponsemessage"]
+      end
+
+      def avs_from(response)
+        AVSResult.new(code: response["card"]["avsresponsecode"]) if response["card"]
+      end
+
+      def cvv_from(response)
+        CVVResult.new(response["card"]["cvvresponsecode"]) if response["card"]
+      end
+
+      def split_authorization(authorization)
+        authorization.split("|")
+      end
+
+      def build_soap_request
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml['soap'].Envelope('xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+                               'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+                               'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/') do
+
+            xml['soap'].Body do
+              yield(xml)
+            end
+          end
+        end
+
+        builder.to_xml
+      end
+
+      def payment_account_type(payment)
+        if payment.is_a?(Check)
+          payment_account_type = payment.account_type
+        else
+          payment_account_type = "CreditCard"
+        end
+        payment_account_type
+      end
+
+      def url(action)
+        if action == "PaymentAccountCreate"
+          url = (test? ? SERVICE_TEST_URL : SERVICE_LIVE_URL)
+        else
+          url = (test? ? test_url : live_url)
+        end
+      end
+
+      def interface(action)
+        return "transaction" if action != "PaymentAccountCreate"
+        return "services" if action == "PaymentAccountCreate"
+      end
+
+      def headers(action)
+        {
+          "Content-Type" => "text/xml; charset=utf-8",
+          "SOAPAction" => "https://#{interface(action)}.elementexpress.com/#{action}"
+        }
+      end
+    end
+  end
+end

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

@@ -1,8 +1,7 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class EpayGateway < Gateway
-      API_HOST = 'ssl.ditonlinebetalingssystem.dk'
-      self.live_url = 'https://' + API_HOST + '/remote/payment'
+      self.live_url = 'https://ssl.ditonlinebetalingssystem.dk/'
 
       self.default_currency = 'DKK'
       self.money_format = :cents
@@ -106,10 +105,22 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r(((?:\?|&)cardno=)\d*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?cvc=)\d*(&?)), '\1[FILTERED]\2')
+      end
+
+
       private
 
       def add_amount(post, money, options)
@@ -175,19 +186,19 @@ module ActiveMerchant #:nodoc:
       def soap_post(method, params)
         data = xml_builder(params, method)
         headers = make_headers(data, method)
-        REXML::Document.new(ssl_post('https://' + API_HOST + '/remote/payment.asmx', data, headers))
+        REXML::Document.new(ssl_post(live_url + 'remote/payment.asmx', data, headers))
       end
 
       def do_authorize(params)
         headers = {}
         headers['Referer'] = (options[:password] || "activemerchant.org")
 
-        response = raw_ssl_request(:post, 'https://' + API_HOST + '/auth/default.aspx', authorize_post_data(params), headers)
+        response = raw_ssl_request(:post, live_url + 'auth/default.aspx', authorize_post_data(params), headers)
 
         # Authorize gives the response back by redirecting with the values in
         # the URL query
         if location = response['Location']
-          query = CGI::parse(URI.parse(location.gsub(' ', '%20')).query)
+          query = CGI::parse(URI.parse(location.gsub(' ', '%20').gsub('<', '%3C').gsub('>', '%3E')).query)
         else
           return {
             'accept' => '0',
@@ -233,9 +244,9 @@ module ActiveMerchant #:nodoc:
       def make_headers(data, soap_call)
         {
           'Content-Type' => 'text/xml; charset=utf-8',
-          'Host' => API_HOST,
+          'Host' => "ssl.ditonlinebetalingssystem.dk",
           'Content-Length' => data.size.to_s,
-          'SOAPAction' => self.live_url + '/' + soap_call
+          'SOAPAction' => self.live_url + 'remote/payment/' + soap_call
         }
       end
 
@@ -246,7 +257,7 @@ module ActiveMerchant #:nodoc:
                                       'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
                                       'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/' } do
             xml.tag! 'soap:Body' do
-              xml.tag! soap_call, { 'xmlns' => self.live_url } do
+              xml.tag! soap_call, { 'xmlns' => "#{self.live_url}remote/payment" } do
                 xml.tag! 'merchantnumber', @options[:login]
                 xml.tag! 'transactionid', params[:transaction]
                 xml.tag! 'amount', params[:amount].to_s if soap_call != 'delete'
@@ -259,8 +270,8 @@ module ActiveMerchant #:nodoc:
       def authorize_post_data(params = {})
         params[:language] = '2'
         params[:cms] = 'activemerchant'
-        params[:accepturl] = 'https://ssl.ditonlinebetalingssystem.dk/auth/default.aspx?accept=1'
-        params[:declineurl] = 'https://ssl.ditonlinebetalingssystem.dk/auth/default.aspx?decline=1'
+        params[:accepturl] = live_url + 'auth/default.aspx?accept=1'
+        params[:declineurl] = live_url + 'auth/default.aspx?decline=1'
         params[:merchantnumber] = @options[:login]
 
         params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
@@ -268,7 +279,7 @@ module ActiveMerchant #:nodoc:
 
       # Limited to 20 digits max
       def format_order_number(number)
-        number.to_s.gsub(/[^\w_]/, '').rjust(4, "0")[0...20]
+        number.to_s.gsub(/[^\w]/, '').rjust(4, "0")[0...20]
       end
     end
   end

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

@@ -8,7 +8,7 @@ module ActiveMerchant #:nodoc:
       self.live_url = 'https://www.eway.com.au'
 
       self.money_format = :cents
-      self.supported_countries = ['AU', 'NZ', 'GB']
+      self.supported_countries = ['AU']
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
       self.homepage_url = 'http://www.eway.com.au/'
       self.display_name = 'eWAY'
@@ -52,6 +52,17 @@ module ActiveMerchant #:nodoc:
         commit(refund_url, money, post)
       end
 
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((<ewayCardNumber>)\d+(</ewayCardNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<ewayCVN>)\d+(</ewayCVN>))i, '\1[FILTERED]\2')
+      end
+
       private
       def requires_address!(options)
         raise ArgumentError.new("Missing eWay required parameters: address or billing_address") unless (options.has_key?(:address) or options.has_key?(:billing_address))
@@ -136,17 +147,6 @@ module ActiveMerchant #:nodoc:
         MESSAGES[message[0,2]] || message
       end
 
-      # Make a ruby type out of the response string
-      def normalize(field)
-        case field
-        when "true"   then true
-        when "false"  then false
-        when ""       then nil
-        when "null"   then nil
-        else field
-        end
-      end
-
       def purchase_url(cvn)
         suffix = test? ? 'xmltest/testpage.asp' : 'xmlpayment.asp'
         gateway_part = cvn ? 'gateway_cvn' : 'gateway'

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

@@ -150,7 +150,7 @@ module ActiveMerchant #:nodoc:
       def parse(body)
         reply = {}
         xml = REXML::Document.new(body)
-         if root = REXML::XPath.first(xml, "//soap:Fault") then
+        if root = REXML::XPath.first(xml, "//soap:Fault") then
            reply=parse_fault(root)
         else
           if root = REXML::XPath.first(xml, '//ProcessPaymentResponse/ewayResponse') then