activemerchant 1.28.0 → 1.29.0

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

@@ -0,0 +1,272 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MercuryGateway < Gateway
+      URLS = {
+        :test => 'https://w1.mercurydev.net/ws/ws.asmx',
+        :live => 'https://w1.mercurypay.com/ws/ws.asmx'
+      }
+
+      self.homepage_url = 'http://www.mercurypay.com'
+      self.display_name = 'Mercury'
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.default_currency = 'USD'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        requires!(options, :order_id)
+
+        request = build_non_authorized_request('Sale', money, credit_card, options)
+        commit('Sale', request)
+      end
+
+      def credit(money, credit_card, options = {})
+        requires!(options, :order_id)
+
+        request = build_non_authorized_request('Return', money, credit_card, options)
+        commit('Return', request)
+      end
+
+      def authorize(money, credit_card, options = {})
+        requires!(options, :order_id)
+
+        options[:authorized] ||= money
+        request = build_non_authorized_request('PreAuth', money, credit_card, options)
+        commit('PreAuth', request)
+      end
+
+      def capture(money, authorization, options = {})
+        requires!(options, :credit_card)
+        options[:authorized] ||= money
+        request = build_authorized_request('PreAuthCapture', money, authorization, options[:credit_card], options)
+        commit('PreAuthCapture', request)
+      end
+
+      def refund(money, authorization, options = {})
+        requires!(options, :credit_card)
+
+        request = build_authorized_request('VoidSale', money, authorization, options[:credit_card], options)
+        commit(options[:void], request)
+      end
+
+      private
+
+      def build_non_authorized_request(action, money, credit_card, options)
+        xml = Builder::XmlMarkup.new
+
+        xml.tag! "TStream" do
+          xml.tag! "Transaction" do
+            xml.tag! 'TranType', 'Credit'
+            xml.tag! 'TranCode', action
+            if action == 'PreAuth' || action == 'Sale'
+              xml.tag! "PartialAuth", "Allow"
+            end
+            add_invoice(xml, options[:order_id], nil, options)
+            add_customer_data(xml, options)
+            add_amount(xml, money, options)
+            add_credit_card(xml, credit_card, action)
+            add_address(xml, options)
+          end
+        end
+        xml = xml.target!
+      end
+
+      def build_authorized_request(action, money, authorization, credit_card, options)
+        xml = Builder::XmlMarkup.new
+
+        invoice_no, ref_no, auth_code, acq_ref_data, process_data = split_authorization(authorization)
+
+        xml.tag! "TStream" do
+          xml.tag! "Transaction" do
+            xml.tag! 'TranType', 'Credit'
+            xml.tag! 'TranCode', action
+            if action == 'PreAuthCapture'
+              xml.tag! "PartialAuth", "Allow"
+            end
+            add_invoice(xml, invoice_no, ref_no, options)
+            add_customer_data(xml, options)
+            add_amount(xml, money, options)
+            add_credit_card(xml, credit_card, action)
+            add_address(xml, options)
+            xml.tag! 'TranInfo' do
+              xml.tag! "AuthCode", auth_code
+              xml.tag! "AcqRefData", acq_ref_data
+              xml.tag! "ProcessData", process_data
+            end
+          end
+        end
+        xml = xml.target!
+      end
+
+      def add_invoice(xml, invoice_no, ref_no, options)
+        if /^\d+$/ !~ invoice_no.to_s
+          raise ArgumentError.new("#{invoice_no} is not numeric as required by Mercury")
+        end
+
+        xml.tag! 'InvoiceNo', invoice_no
+        xml.tag! 'RefNo', ref_no || invoice_no
+        xml.tag! 'OperatorID', options[:merchant] if options[:merchant]
+        xml.tag! 'Memo', options[:description] if options[:description]
+      end
+
+      def add_customer_data(xml, options)
+        xml.tag! 'IpAddress', options[:ip] if options[:ip]
+        if options[:customer]
+          xml.tag! "TranInfo" do
+            xml.tag! 'CustomerCode', options[:customer]
+          end
+        end
+        xml.tag! 'MerchantID', @options[:login]
+      end
+
+      def add_amount(xml, money, options = {})
+        xml.tag! 'Amount' do
+          xml.tag! 'Purchase', amount(money)
+          xml.tag! 'Tax', options[:tax] if options[:tax]
+          xml.tag! 'Authorize', amount(options[:authorized]) if options[:authorized]
+          xml.tag! 'Gratuity', amount(options[:tip]) if options[:tip]
+        end
+      end
+
+      CARD_CODES = {
+        'visa' => 'VISA',
+        'master' => 'M/C',
+        'american_express' => 'AMEX',
+        'discover' => 'DCVR',
+        'diners_club' => 'DCLB',
+        'jcb' => 'JCB'
+      }
+
+      def add_credit_card(xml, credit_card, action)
+        xml.tag! 'Account' do
+          xml.tag! 'AcctNo', credit_card.number
+          xml.tag! 'ExpDate', expdate(credit_card)
+        end
+        xml.tag! 'CardType', CARD_CODES[credit_card.brand] if credit_card.brand
+
+        include_cvv = !%w(Return PreAuthCapture).include?(action)
+        xml.tag! 'CVVData', credit_card.verification_value if(include_cvv && credit_card.verification_value)
+      end
+
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+
+      def add_address(xml, options)
+        if billing_address = options[:billing_address] || options[:address]
+          xml.tag! 'AVS' do
+            xml.tag! 'Address', billing_address[:address1]
+            xml.tag! 'Zip', billing_address[:zip]
+          end
+        end
+      end
+
+      def parse(action, body)
+        response = {}
+        hashify_xml!(unescape_xml(body), response)
+        response
+      end
+
+      def hashify_xml!(xml, response)
+        xml = REXML::Document.new(xml)
+
+        xml.elements.each("//CmdResponse/*") do |node|
+          response[node.name.underscore.to_sym] = node.text
+        end
+
+        xml.elements.each("//TranResponse/*") do |node|
+          if node.name.to_s == "Amount"
+            node.elements.each do |amt|
+              response[amt.name.underscore.to_sym] = amt.text
+            end
+          else
+            response[node.name.underscore.to_sym] = node.text
+          end
+        end
+      end
+
+      def endpoint_url
+        URLS[test? ? :test : :live]
+      end
+
+      def build_soap_request(body)
+        xml = Builder::XmlMarkup.new
+
+        xml.instruct!
+        xml.tag! 'soap:Envelope', ENVELOPE_NAMESPACES do
+          xml.tag! 'soap:Body' do
+            xml.tag! 'CreditTransaction', 'xmlns' => homepage_url do
+              xml.tag! 'tran' do
+                xml << escape_xml(body)
+              end
+              xml.tag! 'pw', @options[:password]
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def build_header
+        {
+          "SOAPAction" => "http://www.mercurypay.com/CreditTransaction",
+          "Content-Type" => "text/xml; charset=utf-8"
+        }
+      end
+
+      SUCCESS_CODES = [ 'Approved', 'Success' ]
+
+      def commit(action, request)
+        response = parse(action, ssl_post(endpoint_url, build_soap_request(request), build_header))
+
+        success = SUCCESS_CODES.include?(response[:cmd_status])
+        message = success ? 'Success' : message_from(response)
+
+        Response.new(success, message, response,
+          :test => test?,
+          :authorization => authorization_from(response),
+          :avs_result => { :code => response[:avs_result] },
+          :cvv_result => response[:cvv_result])
+      end
+
+      def message_from(response)
+        response[:text_response]
+      end
+
+      def authorization_from(response)
+        [
+          response[:invoice_no],
+          response[:ref_no],
+          response[:auth_code],
+          response[:acq_ref_data],
+          response[:process_data]
+        ].join(";")
+      end
+
+      def split_authorization(authorization)
+        invoice_no, ref_no, auth_code, acq_ref_data, process_data = authorization.split(";")
+        [invoice_no, ref_no, auth_code, acq_ref_data, process_data]
+      end
+
+      ENVELOPE_NAMESPACES = {
+        'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+        'xmlns:soap' => "http://schemas.xmlsoap.org/soap/envelope/",
+        'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
+      }
+
+      def escape_xml(xml)
+        "\n<![CDATA[\n#{xml}\n]]>\n"
+      end
+
+      def unescape_xml(escaped_xml)
+        escaped_xml.gsub(/\&gt;/,'>').gsub(/\&lt;/,'<')
+      end
+    end
+  end
+end

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

@@ -48,11 +48,10 @@ module ActiveMerchant #:nodoc:
       #
       # * <tt>:login</tt> -- The username required to access the Metrics Global control panel. (REQUIRED)
       # * <tt>:password</tt> -- The password required to access the Metrics Global control panel. (REQUIRED)
-      # * <tt>:test</tt> -- +true+ or +false+. If true, perform transactions against the test server. 
+      # * <tt>:test</tt> -- +true+ or +false+. If true, perform transactions against the test server.
       #   Otherwise, perform transactions against the production server.
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
 
@@ -156,7 +155,7 @@ module ActiveMerchant #:nodoc:
       end
 
       private
-      
+
       def commit(action, money, parameters)
         parameters[:amount] = amount(money) unless action == 'VOID'
 
@@ -177,8 +176,8 @@ module ActiveMerchant #:nodoc:
         #   (TESTMODE) Successful Sale
         test_mode = test? || message =~ /TESTMODE/
 
-        Response.new(success?(response), message, response, 
-          :test => test_mode, 
+        Response.new(success?(response), message, response,
+          :test => test_mode,
           :authorization => response[:transaction_id],
           :fraud_review => fraud_review?(response),
           :avs_result => { :code => response[:avs_result_code] },
@@ -199,7 +198,7 @@ module ActiveMerchant #:nodoc:
 
         results = {
           :response_code => fields[RESPONSE_CODE].to_i,
-          :response_reason_code => fields[RESPONSE_REASON_CODE], 
+          :response_reason_code => fields[RESPONSE_REASON_CODE],
           :response_reason_text => fields[RESPONSE_REASON_TEXT],
           :avs_result_code => fields[AVS_RESULT_CODE],
           :transaction_id => fields[TRANSACTION_ID],
@@ -252,7 +251,7 @@ module ActiveMerchant #:nodoc:
           post[:customer_ip] = options[:ip]
         end
       end
-      
+
       # x_duplicate_window won't be sent by default, because sending it changes the response.
       # "If this field is present in the request with or without a value, an enhanced duplicate transaction response will be sent."
       def add_duplicate_window(post)
@@ -271,7 +270,7 @@ module ActiveMerchant #:nodoc:
           post[:country] = address[:country].to_s
           post[:state]   = address[:state].blank?  ? 'n/a' : address[:state]
         end
-        
+
         if address = options[:shipping_address]
           post[:ship_to_first_name] = address[:first_name].to_s
           post[:ship_to_last_name] = address[:last_name].to_s
@@ -296,11 +295,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def message_from(results)  
+      def message_from(results)
         if results[:response_code] == DECLINED
           return CVVResult.messages[ results[:card_code] ] if CARD_CODE_ERRORS.include?(results[:card_code])
           if AVS_REASON_CODES.include?(results[:response_reason_code]) && AVS_ERRORS.include?(results[:avs_result_code])
-            return AVSResult.messages[ results[:avs_result_code] ] 
+            return AVSResult.messages[ results[:avs_result_code] ]
           end
         end
 

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

@@ -46,8 +46,6 @@ module ActiveMerchant #:nodoc:
       # * <tt>:advanced_password</tt> -- The MiGS AMA User's password
       def initialize(options = {})
         requires!(options, :login, :password)
-        @test = options[:login].start_with?('TEST')
-        @options = options
         super
       end
 
@@ -180,6 +178,10 @@ module ActiveMerchant #:nodoc:
         response_object(response_hash)
       end
 
+      def test?
+        @options[:login].start_with?('TEST')
+      end
+
       private
 
       def add_advanced_user(post)
@@ -219,7 +221,7 @@ module ActiveMerchant #:nodoc:
 
       def response_object(response)
         Response.new(success?(response), response[:Message], response,
-          :test => @test,
+          :test => test?,
           :authorization => response[:TransactionNo],
           :fraud_review => fraud_review?(response),
           :avs_result => { :code => response[:AVSResultCode] },

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

@@ -7,27 +7,26 @@ module ActiveMerchant #:nodoc:
       self.supported_cardtypes = ModernPaymentsCimGateway.supported_cardtypes
       self.homepage_url = ModernPaymentsCimGateway.homepage_url
       self.display_name = ModernPaymentsCimGateway.display_name
-      
+
       self.abstract_class = true
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
-      
+
       def purchase(money, credit_card, options = {})
         customer_response = cim.create_customer(options)
         return customer_response unless customer_response.success?
-        
+
         customer_id = customer_response.params["create_customer_result"]
-        
+
         card_response = cim.modify_customer_credit_card(customer_id, credit_card)
         return card_response unless card_response.success?
-        
+
         cim.authorize_credit_card_payment(customer_id, money)
       end
-      
+
       private
       def cim
         @cim ||= ModernPaymentsCimGateway.new(@options)

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

@@ -3,66 +3,65 @@ module ActiveMerchant #:nodoc:
     class ModernPaymentsCimGateway < Gateway #:nodoc:
       self.test_url = "https://secure.modpay.com/netservices/test/ModpayTest.asmx"
       self.live_url = 'https://secure.modpay.com/ws/modpay.asmx'
-      
+
       LIVE_XMLNS = "https://secure.modpay.com/ws/"
       TEST_XMLNS = "https://secure.modpay.com/netservices/test/"
-      
+
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.homepage_url = 'http://www.modpay.com'
       self.display_name = 'Modern Payments'
-      
+
       SUCCESS_MESSAGE = "Transaction accepted"
       FAILURE_MESSAGE = "Transaction failed"
       ERROR_MESSAGE   = "Transaction error"
-      
+
       PAYMENT_METHOD = {
         :check => 1,
         :credit_card => 2
       }
-      
+
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
-      end  
-      
+      end
+
       def create_customer(options = {})
         post = {}
         add_customer_data(post, options)
         add_address(post, options)
-        
+
         commit('CreateCustomer', post)
       end
-      
+
       def modify_customer_credit_card(customer_id, credit_card)
         raise ArgumentError, "The customer_id cannot be blank" if customer_id.blank?
-        
+
         post = {}
         add_customer_id(post, customer_id)
         add_credit_card(post, credit_card)
-        
+
         commit('ModifyCustomerCreditCard', post)
       end
-      
+
       def authorize_credit_card_payment(customer_id, amount)
         raise ArgumentError, "The customer_id cannot be blank" if customer_id.blank?
-        
+
         post = {}
         add_customer_id(post, customer_id)
         add_amount(post, amount)
-        
+
         commit('AuthorizeCreditCardPayment', post)
       end
-      
+
       def create_payment(customer_id, amount, options = {})
         raise ArgumentError, "The customer_id cannot be blank" if customer_id.blank?
-        
+
         post = {}
         add_customer_id(post, customer_id)
         add_amount(post, amount)
         add_payment_details(post, options)
-        
+
         commit('CreatePayment', post)
       end
 
@@ -71,22 +70,22 @@ module ActiveMerchant #:nodoc:
         post[:pmtDate] = (options[:payment_date] || Time.now.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
         post[:pmtType] = PAYMENT_METHOD[options[:payment_method] || :credit_card]
       end
-      
+
       def add_amount(post, money)
         post[:pmtAmount] = amount(money)
       end
-      
+
       def add_customer_id(post, customer_id)
         post[:custId] = customer_id
       end
-      
+
       def add_customer_data(post, options)
         post[:acctNum]   = options[:customer]
       end
-      
+
       def add_address(post, options)
         address = options[:billing_address] || options[:address] || {}
-        
+
         if name = address[:name]
           segments = name.split(' ')
           post[:lastName] = segments.pop
@@ -95,7 +94,7 @@ module ActiveMerchant #:nodoc:
           post[:firstName] = address[:first_name]
           post[:lastName]  = address[:last_name]
         end
-        
+
         post[:address]   = address[:address1]
         post[:city]      = address[:city]
         post[:state]     = address[:state]
@@ -104,14 +103,14 @@ module ActiveMerchant #:nodoc:
         post[:fax]       = address[:fax]
         post[:email]     = options[:email]
       end
-      
+
       def add_credit_card(post, credit_card)
         post[:ccName] = credit_card.name
         post[:ccNum]  = credit_card.number
         post[:expMonth] = credit_card.month
         post[:expYear]  = credit_card.year
       end
-                
+
       def build_request(action, params)
         xml = Builder::XmlMarkup.new :indent => 2
         xml.instruct!
@@ -130,7 +129,7 @@ module ActiveMerchant #:nodoc:
         end
         xml.target!
       end
-      
+
       def xmlns(action)
         if test? && action == 'AuthorizeCreditCardPayment'
           TEST_XMLNS
@@ -138,7 +137,7 @@ module ActiveMerchant #:nodoc:
           LIVE_XMLNS
         end
       end
-      
+
       def url(action)
         if test? && action == 'AuthorizeCreditCardPayment'
           self.test_url
@@ -146,39 +145,39 @@ module ActiveMerchant #:nodoc:
           self.live_url
         end
       end
-      
+
       def commit(action, params)
-        data = ssl_post(url(action), build_request(action, params), 
-                 { 'Content-Type' =>'text/xml; charset=utf-8', 
+        data = ssl_post(url(action), build_request(action, params),
+                 { 'Content-Type' =>'text/xml; charset=utf-8',
                    'SOAPAction' => "#{xmlns(action)}#{action}" }
                 )
 
         response = parse(action, data)
-        Response.new(successful?(action, response), message_from(action, response), response, 
-          :test => test?, 
+        Response.new(successful?(action, response), message_from(action, response), response,
+          :test => test?,
           :authorization => authorization_from(action, response),
           :avs_result => { :code => response[:avs_code] }
         )
       end
-      
+
       def authorization_from(action, response)
         response[authorization_key(action)]
       end
-      
+
       def authorization_key(action)
         action == "AuthorizeCreditCardPayment" ? :trans_id : "#{action.underscore}_result".to_sym
       end
-      
+
       def successful?(action, response)
         key = authorization_key(action)
-        
+
         if key == :trans_id
           response[:approved] == "true"
         else
           response[key].to_i > 0
         end
       end
-      
+
       def message_from(action, response)
         if response[:faultcode]
           ERROR_MESSAGE
@@ -188,11 +187,11 @@ module ActiveMerchant #:nodoc:
           FAILURE_MESSAGE
         end
       end
-      
+
       def parse(action, xml)
         response = {}
         response[:action] = action
-        
+
         xml = REXML::Document.new(xml)
         if root = REXML::XPath.first(xml, "//#{action}Response")
           root.elements.to_a.each do |node|
@@ -206,7 +205,7 @@ module ActiveMerchant #:nodoc:
 
         response
       end
-      
+
       def parse_element(response, node)
         if node.has_elements?
           node.elements.each{|e| parse_element(response, e) }