activemerchant 1.42.6 → 1.90.0

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

@@ -1,5 +1,15 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
+    # To perform PCI Compliant Repeat Billing
+    #
+    #   Ensure that PCI Compliant Repeat Billing is enabled on your merchant account:
+    #    "Enable PCI Compliant Repeat Billing, Up-selling and Cross-selling" in Step 6 of the Credit Cards setup page
+    #
+    #  Instead of passing a credit_card to authorize or purchase, pass the transaction id (res.authorization)
+    #  of a past Netbilling transaction
+    #
+    # To store billing information without performing an operation, use the 'store' method
+    # which invokes the tran_type 'Q' (Quasi) operation and returns a transaction id to use in future Repeat Billing operations
     class NetbillingGateway < Gateway
       self.live_url = self.test_url = 'https://secure.netbilling.com:1402/gw/sas/direct3.1'
 
@@ -9,7 +19,8 @@ module ActiveMerchant #:nodoc:
         :refund        => 'R',
         :credit        => 'C',
         :capture       => 'D',
-        :void          => 'U'
+        :void          => 'U',
+        :quasi         => 'Q'
       }
 
       SUCCESS_CODES = [ '1', 'T' ]
@@ -27,24 +38,26 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def authorize(money, credit_card, options = {})
+      def authorize(money, payment_source, options = {})
         post = {}
         add_amount(post, money)
         add_invoice(post, options)
-        add_credit_card(post, credit_card)
-        add_address(post, credit_card, options)
+        add_payment_source(post, payment_source)
+        add_address(post, payment_source, options)
         add_customer_data(post, options)
+        add_user_data(post, options)
 
         commit(:authorization, post)
       end
 
-      def purchase(money, credit_card, options = {})
+      def purchase(money, payment_source, options = {})
         post = {}
         add_amount(post, money)
         add_invoice(post, options)
-        add_credit_card(post, credit_card)
-        add_address(post, credit_card, options)
+        add_payment_source(post, payment_source)
+        add_address(post, payment_source, options)
         add_customer_data(post, options)
+        add_user_data(post, options)
 
         commit(:purchase, post)
       end
@@ -69,6 +82,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(post, credit_card)
         add_address(post, credit_card, options)
         add_customer_data(post, options)
+        add_user_data(post, options)
 
         commit(:credit, post)
       end
@@ -79,10 +93,31 @@ module ActiveMerchant #:nodoc:
         commit(:void, post)
       end
 
+      def store(credit_card, options = {})
+        post = {}
+        add_amount(post, 0)
+        add_payment_source(post, credit_card)
+        add_address(post, credit_card, options)
+        add_customer_data(post, options)
+
+        commit(:quasi, post)
+      end
+
       def test?
         (@options[:login] == TEST_LOGIN || super)
       end
 
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((&?card_number=)[^&]*), '\1[FILTERED]').
+          gsub(%r((&?card_cvv2=)[^&]*), '\1[FILTERED]')
+      end
+
       private
 
       def add_amount(post, money)
@@ -108,23 +143,38 @@ module ActiveMerchant #:nodoc:
           post[:bill_state]      = billing_address[:state]
         end
 
-       if shipping_address = options[:shipping_address]
-         first_name, last_name = parse_first_and_last_name(shipping_address[:name])
-
-         post[:ship_name1]      = first_name
-         post[:ship_name2]      = last_name
-         post[:ship_street]     = shipping_address[:address1]
-         post[:ship_zip]        = shipping_address[:zip]
-         post[:ship_city]       = shipping_address[:city]
-         post[:ship_country]    = shipping_address[:country]
-         post[:ship_state]      = shipping_address[:state]
-       end
+        if shipping_address = options[:shipping_address]
+          post[:ship_name1], post[:ship_name2] = split_names(shipping_address[:name])
+          post[:ship_street]     = shipping_address[:address1]
+          post[:ship_zip]        = shipping_address[:zip]
+          post[:ship_city]       = shipping_address[:city]
+          post[:ship_country]    = shipping_address[:country]
+          post[:ship_state]      = shipping_address[:state]
+        end
       end
 
       def add_invoice(post, options)
         post[:description] = options[:description]
       end
 
+      def add_payment_source(params, source)
+        if source.is_a?(String)
+          add_transaction_id(params, source)
+        else
+          add_credit_card(params, source)
+        end
+      end
+
+      def add_user_data(post, options)
+        if options[:order_id]
+          post[:user_data] = "order_id:#{options[:order_id]}"
+        end
+      end
+
+      def add_transaction_id(post, transaction_id)
+        post[:card_number] = 'CS:' + transaction_id
+      end
+
       def add_credit_card(post, credit_card)
         post[:bill_name1] = credit_card.first_name
         post[:bill_name2] = credit_card.last_name
@@ -136,7 +186,7 @@ module ActiveMerchant #:nodoc:
       def parse(body)
         results = {}
         body.split(/&/).each do |pair|
-          key,val = pair.split(/\=/)
+          key, val = pair.split(/\=/)
           results[key.to_sym] = CGI.unescape(val)
         end
         results
@@ -168,30 +218,15 @@ module ActiveMerchant #:nodoc:
         success?(response) ? SUCCESS_MESSAGE : (response[:auth_msg] || FAILURE_MESSAGE)
       end
 
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-
       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]
 
-        parameters.reject{|k,v| v.blank?}.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        parameters.reject { |k, v| v.blank? }.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
-      def parse_first_and_last_name(value)
-        name = value.to_s.split(' ')
-
-        last_name = name.pop || ''
-        first_name = name.join(' ')
-        [ first_name, last_name ]
-      end
     end
   end
 end
-

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

@@ -51,7 +51,7 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'NETPAY Gateway'
 
       CURRENCY_CODES = {
-        "MXN" => '484'
+        'MXN' => '484'
       }
 
       # The header keys that we will provide in the response params hash
@@ -110,7 +110,6 @@ module ActiveMerchant #:nodoc:
         add_order_id(post, order_id_from(authorization))
         add_amount(post, money, options)
 
-        #commit('Refund', post, options)
         commit('Credit', post, options)
       end
 
@@ -157,7 +156,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def split_authorization(authorization)
-        order_id, amount, currency = authorization.split("|")
+        order_id, amount, currency = authorization.split('|')
         [order_id, amount, currency]
       end
 
@@ -166,8 +165,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
+        year  = sprintf('%.4i', credit_card.year)
+        month = sprintf('%.2i', credit_card.month)
 
         "#{month}/#{year[-2..-1]}"
       end
@@ -191,7 +190,7 @@ module ActiveMerchant #:nodoc:
         add_login_data(parameters)
         add_action(parameters, action, options)
 
-        post = parameters.collect{|key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        post = parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
         parse(ssl_post(url, post), parameters)
       end
 

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

@@ -0,0 +1,241 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NetworkMerchantsGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.networkmerchants.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.nmi.com/'
+      self.display_name = 'Network Merchants (NMI)'
+
+      self.money_format = :dollars
+      self.default_currency = 'USD'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard_or_vault_id, options = {})
+        post = build_auth_post(money, creditcard_or_vault_id, options)
+        commit('auth', post)
+      end
+
+      def purchase(money, creditcard_or_vault_id, options = {})
+        post = build_purchase_post(money, creditcard_or_vault_id, options)
+        commit('sale', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = build_capture_post(money, authorization, options)
+        commit('capture', post)
+      end
+
+      def void(authorization, options = {})
+        post = build_void_post(authorization, options)
+        commit('void', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = build_refund_post(money, authorization, options)
+        commit('refund', post)
+      end
+
+      def store(creditcard, options = {})
+        post = build_store_post(creditcard, options)
+        commit_vault('add_customer', post)
+      end
+
+      def unstore(customer_vault_id, options = {})
+        post = build_unstore_post(customer_vault_id, options)
+        commit_vault('delete_customer', post)
+      end
+
+      private
+
+      def build_auth_post(money, creditcard_or_vault_id, options)
+        post = {}
+        add_order(post, options)
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_vault_id, options)
+        add_amount(post, money, options)
+        post
+      end
+
+      def build_purchase_post(money, creditcard, options)
+        build_auth_post(money, creditcard, options)
+      end
+
+      def build_capture_post(money, authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money, options)
+        post
+      end
+
+      def build_void_post(authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        post
+      end
+
+      def build_refund_post(money, authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money, options)
+        post
+      end
+
+      def build_store_post(creditcard_or_check, options)
+        post = {}
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_check, options)
+        post
+      end
+
+      def build_unstore_post(customer_vault_id, options)
+        post = {}
+        post['customer_vault_id'] = customer_vault_id
+        post
+      end
+
+      def add_order(post, options)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_address(post, options)
+        post[:email] = options[:email]
+        post[:ipaddress] = options[:ip]
+
+        address = options[:billing_address] || options[:address] || {}
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:city] = address[:city]
+        post[:state] = address[:state].blank? ? 'n/a' : address[:state]
+        post[:zip] = address[:zip]
+        post[:country] = address[:country]
+        post[:phone] = address[:phone]
+      end
+
+      def add_shipping_address(post, options)
+        shipping_address = options[:shipping_address] || {}
+        post[:shipping_address1] = shipping_address[:address1]
+        post[:shipping_address2] = shipping_address[:address2]
+        post[:shipping_city] = shipping_address[:city]
+        post[:shipping_state] = shipping_address[:state]
+        post[:shipping_zip] = shipping_address[:zip]
+        post[:shipping_country] = shipping_address[:country]
+      end
+
+      def add_swipe_data(post, creditcard, options)
+        # unencrypted tracks
+        if creditcard.respond_to?(:track_data) && creditcard.track_data.present?
+          post[:track_1] = creditcard.track_data
+        else
+          post[:track_1] = options[:track_1]
+          post[:track_2] = options[:track_2]
+          post[:track_3] = options[:track_3]
+        end
+
+        # encrypted tracks
+        post[:magnesafe_track_1] = options[:magnesafe_track_1]
+        post[:magnesafe_track_2] = options[:magnesafe_track_2]
+        post[:magnesafe_track_3] = options[:magnesafe_track_3]
+        post[:magnesafe_magneprint] = options[:magnesafe_magneprint]
+        post[:magnesafe_ksn] = options[:magnesafe_ksn]
+        post[:magnesafe_magneprint_status] = options[:magnesafe_magneprint_status]
+      end
+
+      def add_payment_method(post, payment_source, options)
+        post[:processor_id] = options[:processor_id]
+        post[:customer_vault] = 'add_customer' if options[:store]
+
+        add_swipe_data(post, payment_source, options)
+
+        if payment_source.is_a?(Check)
+          check = payment_source
+          post[:firstname] = check.first_name
+          post[:lastname] = check.last_name
+          post[:checkname] = check.name
+          post[:checkaba] = check.routing_number
+          post[:checkaccount] = check.account_number
+          post[:account_type] = check.account_type
+          post[:account_holder_type] = check.account_holder_type
+          post[:payment] = 'check'
+        elsif payment_source.respond_to?(:number)
+          creditcard = payment_source
+          post[:firstname] = creditcard.first_name
+          post[:lastname] = creditcard.last_name
+          post[:ccnumber] = creditcard.number
+          post[:ccexp] = format(creditcard.month, :two_digits) + format(creditcard.year, :two_digits)
+          post[:cvv] = creditcard.verification_value
+          post[:payment] = 'creditcard'
+        else
+          post[:customer_vault_id] = payment_source
+        end
+      end
+
+      def add_login(post)
+        post[:username] = @options[:login]
+        post[:password] = @options[:password]
+      end
+
+      def add_amount(post, money, options)
+        post[:currency] = options[:currency] || currency(money)
+        post[:amount] = amount(money)
+      end
+
+      def commit_vault(action, parameters)
+        commit(nil, parameters.merge(:customer_vault => action))
+      end
+
+      def commit(action, parameters)
+        raw = parse(ssl_post(self.live_url, build_request(action, parameters)))
+
+        success = (raw['response'] == ResponseCodes::APPROVED)
+
+        authorization = authorization_from(success, parameters, raw)
+
+        Response.new(success, raw['responsetext'], raw,
+          :test => test?,
+          :authorization => authorization,
+          :avs_result => { :code => raw['avsresponse']},
+          :cvv_result => raw['cvvresponse']
+        )
+      end
+
+      def build_request(action, parameters)
+        parameters[:type] = action if action
+        add_login(parameters)
+        parameters.to_query
+      end
+
+      def authorization_from(success, parameters, response)
+        return nil unless success
+
+        authorization = response['transactionid']
+        if(parameters[:customer_vault] && (authorization.nil? || authorization.empty?))
+          authorization = response['customer_vault_id']
+        end
+
+        authorization
+      end
+
+      class ResponseCodes
+        APPROVED = '1'
+        DENIED = '2'
+        ERROR = '3'
+      end
+
+      def parse(raw_response)
+        rsp = CGI.parse(raw_response)
+        rsp.keys.each { |k| rsp[k] = rsp[k].first } # flatten out the values
+        rsp
+      end
+    end
+  end
+end