activemerchant 1.29.3 → 1.30.0

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

@@ -1,7 +1,10 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class MerchantWareGateway < Gateway
+      class_attribute :v4_live_url
+
       self.live_url = self.test_url = 'https://ps1.merchantware.net/MerchantWARE/ws/RetailTransaction/TXRetail.asmx'
+      self.v4_live_url = 'https://ps1.merchantware.net/Merchantware/ws/RetailTransaction/v4/Credit.asmx'
 
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
@@ -12,13 +15,19 @@ module ActiveMerchant #:nodoc:
                          "xmlns:xsd"  => "http://www.w3.org/2001/XMLSchema",
                          "xmlns:env" => "http://schemas.xmlsoap.org/soap/envelope/"
                        }
+      ENV_NAMESPACES_V4 = { "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/"
+                          }
+
       TX_NAMESPACE = "http://merchantwarehouse.com/MerchantWARE/Client/TransactionRetail"
+      TX_NAMESPACE_V4 = "http://schemas.merchantwarehouse.com/merchantware/40/Credit/"
 
       ACTIONS = {
         :purchase  => "IssueKeyedSale",
         :authorize => "IssueKeyedPreAuth",
         :capture   => "IssuePostAuth",
-        :void      => "IssueVoid",
+        :void      => "VoidPreAuthorization",
         :credit    => "IssueKeyedRefund",
         :reference_credit => "IssueRefundByReference"
       }
@@ -80,11 +89,10 @@ module ActiveMerchant #:nodoc:
       # * <tt>authorization</tt> - The authorization string returned from the initial authorization or purchase.
       def void(authorization, options = {})
         reference, options[:order_id] = split_reference(authorization)
-
-        request = soap_request(:void) do |xml|
-          add_reference(xml, reference)
+        request = v4_soap_request(:void) do |xml|
+          add_reference_token(xml, reference)
         end
-        commit(:void, request)
+        commit(:void, request, true)
       end
 
       # Refund an amount back a cardholder
@@ -108,7 +116,6 @@ module ActiveMerchant #:nodoc:
         perform_reference_credit(money, reference, options)
       end
 
-
       private
 
       def soap_request(action)
@@ -125,6 +132,22 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def v4_soap_request(action)
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        xml.tag! "soap:Envelope", ENV_NAMESPACES_V4 do
+          xml.tag! "soap:Body" do
+            xml.tag! ACTIONS[:void], "xmlns" => TX_NAMESPACE_V4 do
+              xml.tag! "merchantName", @options[:name]
+              xml.tag! "merchantSiteId", @options[:login]
+              xml.tag! "merchantKey", @options[:password]
+              yield xml
+            end
+          end
+        end
+        xml.target!
+      end
+
       def build_purchase_request(action, money, credit_card, options)
         requires!(options, :order_id)
 
@@ -195,6 +218,10 @@ module ActiveMerchant #:nodoc:
         xml.tag! "strReferenceCode", reference
       end
 
+      def add_reference_token(xml, reference)
+        xml.tag! "token", reference
+      end
+
       def add_address(xml, options)
         if address = options[:billing_address] || options[:address]
           xml.tag! "strAVSStreetAddress", address[:address1]
@@ -258,11 +285,19 @@ module ActiveMerchant #:nodoc:
         response
       end
 
-      def commit(action, request)
+      def soap_action(action, v4 = false)
+        v4 ? "#{TX_NAMESPACE_V4}#{ACTIONS[action]}" : "#{TX_NAMESPACE}/#{ACTIONS[action]}"
+      end
+
+      def url(v4 = false)
+        v4 ? v4_live_url : live_url
+      end
+
+      def commit(action, request, v4 = false)
         begin
-          data = ssl_post(self.live_url, request,
+          data = ssl_post(url(v4), request,
                    "Content-Type" => 'text/xml; charset=utf-8',
-                   "SOAPAction"   => "http://merchantwarehouse.com/MerchantWARE/Client/TransactionRetail/#{ACTIONS[action]}"
+                   "SOAPAction"   => soap_action(action, v4)
                  )
           response = parse(action, data)
         rescue ActiveMerchant::ResponseError => e

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

@@ -0,0 +1,190 @@
+require 'digest/md5'
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MerchantWarriorGateway < Gateway
+      TOKEN_TEST_URL = 'https://base.merchantwarrior.com/token/'
+      TOKEN_LIVE_URL = 'https://api.merchantwarrior.com/token/'
+
+      POST_TEST_URL = 'https://base.merchantwarrior.com/post/'
+      POST_LIVE_URL = 'https://api.merchantwarrior.com/post/'
+
+      self.supported_countries = ['AU']
+      self.supported_cardtypes = [:visa, :master, :american_express,
+                                  :diners_club, :discover]
+      self.homepage_url = 'http://www.merchantwarrior.com/'
+      self.display_name = 'MerchantWarrior'
+
+      self.money_format = :dollars
+      self.default_currency = 'AUD'
+
+      def initialize(options = {})
+        requires!(options, :merchant_uuid, :api_key, :api_passphrase)
+        super
+      end
+
+      def authorize(money, payment_method, options = {})
+        post = {}
+        add_amount(post, money, options)
+        add_product(post, options)
+        add_address(post, options)
+        add_payment_method(post, payment_method)
+        commit('processAuth', post)
+      end
+
+      def purchase(money, payment_method, options = {})
+        post = {}
+        add_amount(post, money, options)
+        add_product(post, options)
+        add_address(post, options)
+        add_payment_method(post, payment_method)
+        commit('processCard', post)
+      end
+
+      def capture(money, identification)
+        post = {}
+        add_amount(post, money, options)
+        add_transaction(post, identification)
+        post.merge!('captureAmount' => money.to_s)
+        commit('processCapture', post)
+      end
+
+      def refund(money, identification)
+        post = {}
+        add_amount(post, money, options)
+        add_transaction(post, identification)
+        post['refundAmount'] = money
+        commit('refundCard', post)
+      end
+
+      def store(creditcard, options = {})
+        post = {
+          'cardName' => creditcard.name,
+          'cardNumber' => creditcard.number,
+          'cardExpiryMonth' => sprintf('%02d', creditcard.month),
+          'cardExpiryYear' => sprintf('%02d', creditcard.year)
+        }
+        commit('addCard', post)
+      end
+
+      private
+
+      def add_transaction(post, identification)
+        post['transactionID'] = identification
+      end
+
+      def add_address(post, options)
+        return unless(address = options[:address])
+
+        post['customerName'] = address[:name]
+        post['customerCountry'] = address[:country]
+        post['customerState'] = address[:state]
+        post['customerCity'] = address[:city]
+        post['customerAddress'] = address[:address1]
+        post['customerPostCode'] = address[:zip]
+      end
+
+      def add_product(post, options)
+        post['transactionProduct'] = options[:transaction_product]
+      end
+
+      def add_payment_method(post, payment_method)
+        if payment_method.respond_to?(:number)
+          add_creditcard(post, payment_method)
+        else
+          add_token(post, payment_method)
+        end
+      end
+
+      def add_token(post, token)
+        post['cardID'] = token
+      end
+
+      def add_creditcard(post, creditcard)
+        post['paymentCardNumber'] = creditcard.number
+        post['paymentCardName'] = creditcard.name
+        post['paymentCardExpiry'] = creditcard.expiry_date.expiration.strftime("%m%y")
+      end
+
+      def add_amount(post, money, options)
+        currency = (options[:currency] || currency(money))
+
+        post['transactionAmount'] = money.to_s
+        post['transactionCurrency'] = currency
+        post['hash'] = verification_hash(money, currency)
+      end
+
+      def verification_hash(money, currency)
+        Digest::MD5.hexdigest(
+          (
+            @options[:api_passphrase].to_s +
+            @options[:merchant_uuid].to_s +
+            money.to_s +
+            currency
+          ).downcase
+        )
+      end
+
+      def parse(body)
+        xml = REXML::Document.new(body)
+
+        response = {}
+        xml.root.elements.to_a.each do |node|
+          parse_element(response, node)
+        end
+        response
+      end
+
+      def parse_element(response, node)
+        if node.has_elements?
+          node.elements.each{|element| parse_element(response, element)}
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+
+      def commit(action, post)
+        add_auth(action, post)
+
+        response = parse(ssl_post(url_for(action, post), post_data(post)))
+
+        Response.new(
+          success?(response),
+          response[:response_message],
+          response,
+          :test => test?,
+          :authorization => (response[:card_id] || response[:transaction_id])
+        )
+      end
+
+      def add_auth(action, post)
+        post['merchantUUID'] = @options[:merchant_uuid]
+        post['apiKey'] = @options[:api_key]
+        unless token?(post)
+          post['method'] = action
+        end
+      end
+
+      def url_for(action, post)
+        if token?(post)
+          [(test? ? TOKEN_TEST_URL : TOKEN_LIVE_URL), action].join("/")
+        else
+          (test? ? POST_TEST_URL : POST_LIVE_URL)
+        end
+      end
+
+      def token?(post)
+        (post["cardID"] || post["cardName"])
+      end
+
+      def success?(response)
+        (response[:response_code] == '0')
+      end
+
+      def post_data(post)
+        post.collect{|k,v| "#{k}=#{CGI.escape(v.to_s)}" }.join("&")
+      end
+    end
+  end
+end

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

@@ -70,15 +70,13 @@ module ActiveMerchant #:nodoc:
         commit 'completion', crediting_params(authorization, :comp_amount => amount(money))
       end
 
-      # Voiding requires the original transaction ID and order ID of some open
-      # transaction. Closed transactions must be refunded. Note that the only
-      # methods which may be voided are +capture+ and +purchase+.
+      # Voiding cancels an open authorization.
       #
       # Concatenate your transaction number and order_id by using a semicolon
       # (';'). This is to keep the Moneris interface consistent with other
       # gateways. (See +capture+ for details.)
       def void(authorization, options = {})
-        commit 'purchasecorrection', crediting_params(authorization)
+        capture(0, authorization, options)
       end
 
       # Performs a refund. This method requires that the original transaction

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

@@ -34,7 +34,7 @@ module ActiveMerchant #:nodoc:
       #Transactions currently accepted by NAB Transact XML API
       TRANSACTIONS = {
         :purchase => 0,         #Standard Payment
-        :credit => 4,           #Refund
+        :refund => 4,           #Refund
         :void => 6,             #Client Reversal (Void)
         :authorization => 10,   #Preauthorise
         :capture => 11          #Preauthorise Complete (Advice)
@@ -66,6 +66,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def refund(money, authorization, options = {})
+        commit :refund, build_reference_request(money, authorization)
+      end
+
       def store(creditcard, options = {})
         requires!(options, :billing_id, :amount)
         commit_periodic(build_periodic_item(:addcrn, options[:amount], creditcard, options))
@@ -104,10 +108,23 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def build_reference_request(money, reference)
+        xml = Builder::XmlMarkup.new
+
+        transaction_id, order_id, preauth_id, original_amount = reference.split('*')
+
+        xml.tag! 'amount', (money ? amount(money) : original_amount)
+        xml.tag! 'currency', options[:currency] || currency(money)
+        xml.tag! 'txnID', transaction_id
+        xml.tag! 'purchaseOrderNo', order_id
+        xml.tag! 'preauthID', preauth_id
+
+        xml.target!
+      end
+
       #Generate payment request XML
       # - API is set to allow multiple Txn's but currentlu only allows one
       # - txnSource = 23 - (XML)
-
       def build_request(action, body)
         xml = Builder::XmlMarkup.new
         xml.instruct!
@@ -210,7 +227,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(response)
-        response[:txn_id]
+        [response[:txn_id], response[:purchase_order_no], response[:preauth_id], response[:amount]].join('*')
       end
 
       def message_from(response)

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

@@ -177,6 +177,7 @@ module ActiveMerchant #:nodoc:
 
       def post_data(action, parameters = {})
         parameters[:account_id] = @options[:login]
+        parameters[:site_tag] = @options[:site_tag] if @options[:site_tag].present?
         parameters[:pay_type] = 'C'
         parameters[:tran_type] = TRANSACTIONS[action]
 

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

@@ -0,0 +1,223 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    #
+    # NETPAY Gateway
+    #
+    # Support for NETPAY's HTTP Connector payment gateway in Mexico.
+    #
+    # The gateway sends requests as HTTP POST and receives the response details
+    # in the HTTP header, making the process really rather simple.
+    #
+    # Support for calls to the authorize and capture methods have been included
+    # as per the Netpay manuals, however, your millage may vary with these
+    # methods. At the time of writing (January 2013) they were not fully
+    # supported by the production or test gateways. This situation is
+    # expected to change within a few weeks/months.
+    #
+    # Purchases can be cancelled (`#void`) only within 24 hours of the
+    # transaction. After this, a refund should be performed instead.
+    #
+    # In addition to the regular ActiveMerchant transaction options, NETPAY
+    # also supports a `:mode` parameter. This allows testing to be peformed
+    # in production and force specific results.
+    #
+    #  * 'P' - Production
+    #  * 'A' - Approved
+    #  * 'D' - Declined
+    #  * 'R' - Random (Approved or Declined)
+    #  * 'T' - Test
+    #
+    # For example:
+    #
+    #     response = @gateway.purchase(1000, card, :mode => 'D')
+    #     response.success  # false
+    #
+    class NetpayGateway < Gateway
+      self.test_url = 'http://200.57.87.243:8855'
+      self.live_url = 'https://suite.netpay.com.mx/acquirerprd'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['MX']
+
+      self.default_currency = 'MXN'
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.netpay.com.mx'
+
+      # The name of the gateway
+      self.display_name = 'NETPAY Gateway'
+
+      CURRENCY_CODES = {
+        "MXN" => '484'
+      }
+
+      # The header keys that we will provide in the response params hash
+      RESPONSE_KEYS = ['ResponseMsg', 'ResponseText', 'ResponseCode', 'TimeIn', 'TimeOut', 'AuthCode', 'OrderId', 'CardTypeName', 'MerchantId', 'IssuerAuthDate']
+
+      def initialize(options = {})
+        requires!(options, :store_id, :login, :password)
+        super
+      end
+
+      # Send an authorization request
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+
+        commit('PreAuth', post, options)
+      end
+
+      # Capture an authorization
+      def capture(money, authorization, options = {})
+        post = {}
+        add_order_id(post, order_id_from(authorization))
+        add_amount(post, money, options)
+
+        commit('PostAuth', post, options)
+      end
+
+      # Cancel an auth/purchase within first 24 hours
+      def void(authorization, options = {})
+        post = {}
+        order_id, amount, currency = split_authorization(authorization)
+        add_order_id(post, order_id)
+        post['Total'] = (options[:amount] || amount)
+        post['CurrencyCode'] = currency
+
+        commit('Refund', post, options)
+      end
+
+      # Make a purchase.
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+
+        commit('Auth', post, options)
+      end
+
+      # Perform a Credit transaction.
+      def refund(money, authorization, options = {})
+        post = {}
+        add_order_id(post, order_id_from(authorization))
+        add_amount(post, money, options)
+
+        #commit('Refund', post, options)
+        commit('Credit', post, options)
+      end
+
+      private
+
+      def add_login_data(post)
+        post['StoreId']     = @options[:store_id]
+        post['UserName']    = @options[:login]
+        post['Password']    = @options[:password]
+      end
+
+      def add_action(post, action, options)
+        post['ResourceName'] = action
+        post['ContentType']  = 'Transaction'
+        post['Mode']         = options[:mode] || 'P'
+      end
+
+      def add_order_id(post, order_id)
+        post['OrderId'] = order_id
+      end
+
+      def add_amount(post, money, options)
+        post['Total'] = amount(money)
+        post['CurrencyCode'] = currency_code(options[:currency] || currency(money))
+      end
+
+      def add_customer_data(post, options)
+        post['IPAddress'] = options[:ip] unless options[:ip].blank?
+      end
+
+      def add_invoice(post, options)
+        post['Comments'] = options[:description] if options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        post['CardNumber']   = creditcard.number
+        post['ExpDate']      = expdate(creditcard)
+        post['CustomerName'] = creditcard.name
+        post['CVV2']         = creditcard.verification_value unless creditcard.verification_value.nil?
+      end
+
+      def build_authorization(request_params, response_params)
+        [response_params['OrderId'], request_params['Total'], request_params['CurrencyCode']].join('|')
+      end
+
+      def split_authorization(authorization)
+        order_id, amount, currency = authorization.split("|")
+        [order_id, amount, currency]
+      end
+
+      def order_id_from(authorization)
+        split_authorization(authorization).first
+      end
+
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}/#{year[-2..-1]}"
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(response, request_params)
+        response_params = params_from_response(response)
+
+        success = (response_params['ResponseCode'] == '00')
+        message = response_params['ResponseText'] || response_params['ResponseMsg']
+        options = @options.merge(:test => test?,
+                                 :authorization => build_authorization(request_params, response_params))
+
+        Response.new(success, message, response_params, options)
+      end
+
+      def commit(action, parameters, options)
+        add_login_data(parameters)
+        add_action(parameters, action, options)
+
+        post = parameters.collect{|key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        parse(ssl_post(url, post), parameters)
+      end
+
+      # Override the regular handle response so we can access the headers
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300
+          response
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
+      # Return a hash containing all the useful, or informative values from netpay
+      def params_from_response(response)
+        params = {}
+        RESPONSE_KEYS.each do |k|
+          params[k] = response[k] unless response[k].to_s.empty?
+        end
+        params
+      end
+
+      def currency_code(currency)
+        return currency if currency =~ /^\d+$/
+        CURRENCY_CODES[currency]
+      end
+    end
+  end
+end