activemerchant 1.28.0 → 1.29.1

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

@@ -0,0 +1,300 @@
+require "nokogiri"
+require "cgi"
+
+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.money_format = :cents
+      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 Rapid 3.0"
+      self.default_currency = "AUD"
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      # Public: Run a purchase transaction. Treats the Rapid 3.0 transparent
+      # redirect as an API endpoint in order to conform to the standard
+      # ActiveMerchant #purchase API.
+      #
+      # amount  - The monetary amount of the transaction in cents.
+      # options - A standard ActiveMerchant options hash:
+      #           :order_id         - A merchant-supplied identifier for the
+      #                               transaction (optional).
+      #           :description      - A merchant-supplied description of the
+      #                               transaction (optional).
+      #           :currency         - Three letter currency code for the
+      #                               transaction (default: "AUD")
+      #           :billing_address  - Standard ActiveMerchant address hash
+      #                               (optional).
+      #           :shipping_address - Standard ActiveMerchant address hash
+      #                               (optional).
+      #           :ip               - The ip of the consumer initiating the
+      #                               transaction (optional).
+      #           :application_id   - A string identifying the application
+      #                               submitting the transaction
+      #                               (default: "https://github.com/Shopify/active_merchant")
+      #
+      # Returns an ActiveMerchant::Billing::Response object
+      def purchase(amount, payment_method, options={})
+        MultiResponse.new.tap do |r|
+          # Rather than follow the redirect, we detect the 302 and capture the
+          # token out of the Location header in the run_purchase step. But we
+          # still need a placeholder url to pass to eWay, and that is what
+          # example.com is used for here.
+          r.process{setup_purchase(amount, options.merge(:redirect_url => "http://example.com/"))}
+          r.process{run_purchase(r.authorization, payment_method, r.params["formactionurl"])}
+          r.process{status(r.authorization)}
+        end
+      end
+
+      # Public: Acquire the token necessary to run a transparent redirect.
+      #
+      # amount  - The monetary amount of the transaction in cents.
+      # options - A supplemented ActiveMerchant options hash:
+      #           :redirect_url     - The url to return the customer to after
+      #                               the transparent redirect is completed
+      #                               (required).
+      #           :order_id         - A merchant-supplied identifier for the
+      #                               transaction (optional).
+      #           :description      - A merchant-supplied description of the
+      #                               transaction (optional).
+      #           :currency         - Three letter currency code for the
+      #                               transaction (default: "AUD")
+      #           :billing_address  - Standard ActiveMerchant address hash
+      #                               (optional).
+      #           :shipping_address - Standard ActiveMerchant address hash
+      #                               (optional).
+      #           :ip               - The ip of the consumer initiating the
+      #                               transaction (optional).
+      #           :application_id   - A string identifying the application
+      #                               submitting the transaction
+      #                               (default: "https://github.com/Shopify/active_merchant")
+      #
+      # Returns an EwayRapidResponse object, which conforms to the
+      # ActiveMerchant::Billing::Response API, but also exposes #form_url.
+      def setup_purchase(amount, options={})
+        requires!(options, :redirect_url)
+        request = build_xml_request("CreateAccessCodeRequest") do |doc|
+          add_metadata(doc, options)
+          add_invoice(doc, amount, options)
+          add_customer_data(doc, options)
+        end
+
+        commit(url_for("CreateAccessCode"), request)
+      end
+
+      # Public: Retrieve the status of a transaction.
+      #
+      # identification - The Eway Rapid 3.0 access code for the transaction
+      #                  (returned as the response.authorization by
+      #                  #setup_purchase).
+      #
+      # Returns an EwayRapidResponse object.
+      def status(identification)
+        request = build_xml_request("GetAccessCodeResultRequest") do |doc|
+          doc.AccessCode identification
+        end
+        commit(url_for("GetAccessCodeResult"), request)
+      end
+
+      private
+
+      def run_purchase(identification, payment_method, endpoint)
+        post = {
+          "accesscode" => identification
+        }
+        add_credit_card(post, payment_method)
+
+        commit_form(endpoint, build_form_request(post))
+      end
+
+      def add_metadata(doc, options)
+        doc.RedirectUrl(options[:redirect_url])
+        doc.CustomerIP options[:ip] if options[:ip]
+        doc.Method "ProcessPayment"
+        doc.DeviceID(options[:application_id] || application_id)
+      end
+
+      def add_invoice(doc, money, options)
+        doc.Payment do
+          doc.TotalAmount amount(money)
+          doc.InvoiceReference options[:order_id]
+          doc.InvoiceDescription options[:description]
+          currency_code = (options[:currency] || currency(money) || default_currency)
+          doc.CurrencyCode currency_code
+        end
+      end
+
+      def add_customer_data(doc, options)
+        doc.Customer do
+          add_address(doc, (options[:billing_address] || options[:address]), {:email => options[:email]})
+        end
+        doc.ShippingAddress do
+          add_address(doc, options[:shipping_address], {:skip_company => true})
+        end
+      end
+
+      def add_address(doc, address, options={})
+        return unless address
+        if name = address[:name]
+          parts = name.split(/\s+/)
+          doc.FirstName parts.shift if parts.size > 1
+          doc.LastName parts.join(" ")
+        end
+        doc.CompanyName address[:company] unless options[:skip_company]
+        doc.Street1 address[:address1]
+        doc.Street2 address[:address2]
+        doc.City address[:city]
+        doc.State address[:state]
+        doc.PostalCode address[:zip]
+        doc.Country address[:country]
+        doc.Phone address[:phone]
+        doc.Fax address[:fax]
+        doc.Email options[:email]
+      end
+
+      def add_credit_card(post, credit_card)
+        post["cardname"] = credit_card.name
+        post["cardnumber"] = credit_card.number
+        post["cardexpirymonth"] = credit_card.month
+        post["cardexpiryyear"] = credit_card.year
+        post["cardcvn"] = credit_card.verification_value
+      end
+
+      def build_xml_request(root)
+        builder = Nokogiri::XML::Builder.new
+        builder.__send__(root) do |doc|
+          yield(doc)
+        end
+        builder.to_xml
+      end
+
+      def build_form_request(post)
+        request = []
+        post.each do |key, value|
+          request << "EWAY_#{key.upcase}=#{CGI.escape(value.to_s)}"
+        end
+        request.join("&")
+      end
+
+      def url_for(action)
+        (test? ? test_url : live_url) + action + ".xml"
+      end
+
+      def commit(url, request, form_post=false)
+        headers = {
+          "Authorization" => ("Basic " + Base64.strict_encode64(@options[:login].to_s + ":" + @options[:password].to_s).chomp),
+          "Content-Type" => "text/xml"
+        }
+
+        raw = parse(ssl_post(url, request, headers))
+
+        succeeded = success?(raw)
+        EwayRapidResponse.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          :authorization => authorization_from(raw),
+          :test => test?,
+          :avs_result => avs_result_from(raw),
+          :cvv_result => cvv_result_from(raw)
+        )
+      rescue ActiveMerchant::ResponseError => e
+        return EwayRapidResponse.new(false, e.response.message, {:status_code => e.response.code}, :test => test?)
+      end
+
+      def commit_form(url, request)
+        http_response = raw_ssl_request(:post, url, request)
+
+        success = (http_response.code.to_s == "302")
+        message = (success ? "Succeeded" : http_response.body)
+        if success
+          authorization = CGI.unescape(http_response["Location"].split("=").last)
+        end
+        Response.new(success, message, {:location => http_response["Location"]}, :authorization => authorization, :test => test?)
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath("*").each do |node|
+          if (node.elements.size == 0)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name.downcase}_#{childnode.name.downcase}"
+              response[name.to_sym] = childnode.text
+            end
+          end
+        end unless doc.root.nil?
+
+        response
+      end
+
+      def success?(response)
+        if response[:errors]
+          false
+        elsif response[:transactionstatus]
+          (response[:transactionstatus] == "true")
+        else
+          true
+        end
+      end
+
+      def message_from(succeeded, response)
+        if response[:errors]
+          response[:errors]
+        elsif response[:responsecode]
+          ActiveMerchant::Billing::EwayGateway::MESSAGES[response[:responsecode]]
+        elsif response[:responsemessage]
+          response[:responsemessage]
+        elsif succeeded
+          "Succeeded"
+        else
+          "Failed"
+        end
+      end
+
+      def authorization_from(response)
+        response[:accesscode]
+      end
+
+      def avs_result_from(response)
+        code = case response[:verification_address]
+        when "Valid"
+          "M"
+        when "Invalid"
+          "N"
+        else
+          "I"
+        end
+        {:code => code}
+      end
+
+      def cvv_result_from(response)
+        case response[:verification_cvn]
+        when "Valid"
+          "M"
+        when "Invalid"
+          "N"
+        else
+          "P"
+        end
+      end
+
+      class EwayRapidResponse < ActiveMerchant::Billing::Response
+        def form_url
+          params["formactionurl"]
+        end
+      end
+    end
+  end
+end

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

@@ -2,67 +2,58 @@ module ActiveMerchant #:nodoc:
   module Billing #: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"
-      
+
       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'
                             }
-                            
+
       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'
                                           }
-      
+
       POST_HEADERS = { 'soapAction' => "http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/SendAndCommit",
-                       'Content-Type' => 'text/xml' 
+                       'Content-Type' => 'text/xml'
                      }
-                     
+
       SUCCESS = "true"
-      
+
       SENSITIVE_FIELDS = [ :verification_str2, :expiry_date, :card_number ]
-      
+
       self.supported_cardtypes = [:visa, :master, :american_express, :jcb, :discover]
       self.supported_countries = ['CA', 'US']
       self.homepage_url = 'http://www.e-xact.com'
       self.display_name = 'E-xact'
-  
+
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
-        
-        if TEST_LOGINS.include?( { :login => options[:login], :password => options[:password] } )
-          @test_mode = true
-        end
-      
+
         super
       end
-      
-      def test?
-        @test_mode || Base.gateway_mode == :test
-      end
-      
+
       def authorize(money, credit_card, options = {})
         commit(:authorization, build_sale_or_authorization_request(money, credit_card, options))
       end
-      
+
       def purchase(money, credit_card, options = {})
         commit(:sale, build_sale_or_authorization_request(money, credit_card, options))
       end
-    
+
       def capture(money, authorization, options = {})
         commit(:capture, build_capture_or_credit_request(money, authorization, options))
       end
@@ -75,11 +66,11 @@ module ActiveMerchant #:nodoc:
       def refund(money, authorization, options = {})
         commit(:credit, build_capture_or_credit_request(money, authorization, options))
       end
-         
-      private                       
+
+      private
       def build_request(action, body)
         xml = Builder::XmlMarkup.new
-        
+
         xml.instruct!
         xml.tag! 'env:Envelope', ENVELOPE_NAMESPACES do
           xml.tag! 'env:Body' do
@@ -94,59 +85,59 @@ module ActiveMerchant #:nodoc:
         end
         xml.target!
       end
-                
+
       def build_sale_or_authorization_request(money, credit_card, options)
         xml = Builder::XmlMarkup.new
- 
+
         add_amount(xml, money)
         add_credit_card(xml, credit_card)
         add_customer_data(xml, options)
         add_invoice(xml, options)
-        
-        xml.target!        
+
+        xml.target!
       end
-      
+
       def build_capture_or_credit_request(money, identification, options)
         xml = Builder::XmlMarkup.new
-  
+
         add_identification(xml, identification)
         add_amount(xml, money)
         add_customer_data(xml, options)
-    
+
         xml.target!
       end
-      
+
       def add_credentials(xml)
         xml.tag! 'ExactID', @options[:login]
         xml.tag! 'Password', @options[:password]
       end
-      
+
       def add_transaction_type(xml, action)
         xml.tag! 'Transaction_Type', TRANSACTIONS[action]
       end
-      
+
       def add_identification(xml, identification)
         authorization_num, transaction_tag = identification.split(';')
- 
+
         xml.tag! 'Authorization_Num', authorization_num
         xml.tag! 'Transaction_Tag', transaction_tag
       end
-      
+
       def add_amount(xml, money)
         xml.tag! 'DollarAmount', amount(money)
       end
-      
+
       def add_credit_card(xml, credit_card)
         xml.tag! 'Card_Number', credit_card.number
         xml.tag! 'Expiry_Date', expdate(credit_card)
         xml.tag! 'CardHoldersName', credit_card.name
-        
+
         if credit_card.verification_value?
           xml.tag! 'CVD_Presence_Ind', '1'
           xml.tag! 'VerificationStr2', credit_card.verification_value
         end
       end
-      
+
       def add_customer_data(xml, options)
         xml.tag! 'Customer_Ref', options[:customer]
         xml.tag! 'Client_IP', options[:ip]
@@ -155,22 +146,22 @@ module ActiveMerchant #:nodoc:
 
       def add_address(xml, options)
         if address = options[:billing_address] || options[:address]
-          xml.tag! 'ZipCode', address[:zip]       
-        end    
+          xml.tag! 'ZipCode', address[:zip]
+        end
       end
 
       def add_invoice(xml, options)
         xml.tag! 'Reference_No', options[:order_id]
         xml.tag! 'Reference_3',  options[:description]
       end
-      
+
       def expdate(credit_card)
         "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
       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),
@@ -178,19 +169,19 @@ module ActiveMerchant #:nodoc:
            :cvv_result => response[:cvv2]
          )
       end
-      
+
       def successful?(response)
         response[:transaction_approved] == SUCCESS
       end
-      
+
       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
-      
+
       def message_from(response)
         if response[:faultcode] && response[:faultstring]
           response[:faultstring]
@@ -202,11 +193,11 @@ module ActiveMerchant #:nodoc:
           result
         end
       end
-      
+
       def parse(xml)
         response = {}
         xml = REXML::Document.new(xml)
-        
+
         if root = REXML::XPath.first(xml, "//types:TransactionResult")
           parse_elements(response, root)
         elsif root = REXML::XPath.first(xml, "//soap:Fault")

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

@@ -22,7 +22,6 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
 
@@ -101,7 +100,7 @@ module ActiveMerchant #:nodoc:
         post[:orderid] = options[:order_id]
         post[:orderdescription] = options[:description]
       end
-      
+
       def add_creditcard(post, creditcard)
         post[:ccnumber] = creditcard.number
         post[:ccexp] = expdate(creditcard)
@@ -121,7 +120,7 @@ module ActiveMerchant #:nodoc:
           memo
         end
       end
-      
+
       def commit(action, money, parameters)
         parameters[:amount] = amount(money)
         data = ssl_post(self.live_url, post_data(action, parameters))
@@ -129,7 +128,7 @@ module ActiveMerchant #:nodoc:
         message = message_from(response)
         test_mode = test?
 
-        Response.new(success?(response), message, response, 
+        Response.new(success?(response), message, response,
           :test => test?,
           :authorization => response['transactionid'],
           :avs_result => {:code =>  response['avsresponse']},