activemerchant 1.45.0 → 1.126.0

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

@@ -1,5 +1,5 @@
-require File.dirname(__FILE__) +  '/smart_ps.rb'
-require File.dirname(__FILE__) + '/braintree/braintree_common'
+require 'active_merchant/billing/gateways/smart_ps.rb'
+require 'active_merchant/billing/gateways/braintree/braintree_common'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -7,7 +7,7 @@ module ActiveMerchant #:nodoc:
       include BraintreeCommon
 
       self.display_name = 'Braintree (Orange Platform)'
-      self.supported_countries = ["US"]
+      self.supported_countries = ['US']
 
       self.live_url = self.test_url = 'https://secure.braintreepaymentgateway.com/api/transact.php'
 
@@ -17,4 +17,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -1,48 +1,47 @@
-require "nokogiri"
+require 'nokogiri'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class BridgePayGateway < Gateway
-      self.display_name = "BridgePay"
-      self.homepage_url = "http://www.bridgepaynetwork.com/"
+      self.display_name = 'BridgePay'
+      self.homepage_url = 'http://www.bridgepaynetwork.com/'
 
-      self.test_url = "https://gatewaystage.itstgate.com/SmartPayments/transact.asmx/ProcessCreditCard"
-      self.live_url = "https://gateway.itstgate.com/SmartPayments/transact.asmx/ProcessCreditCard"
+      self.test_url = 'https://gatewaystage.itstgate.com/SmartPayments/transact3.asmx'
+      self.live_url = 'https://gateway.itstgate.com/SmartPayments/transact3.asmx'
 
-      self.supported_countries = ["CA", "US"]
-      self.default_currency = "USD"
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.supported_countries = %w[CA US]
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover diners_club jcb]
 
-
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :user_name, :password)
         super
       end
 
-      def purchase(amount, creditcard, options={})
-        post = post_required_fields("Sale")
+      def purchase(amount, payment_method, options = {})
+        post = initialize_required_fields('Sale')
 
         # Allow the same amount in multiple transactions.
-        post[:ExtData] = "<Force>T</Force>"
+        post[:ExtData] = '<Force>T</Force>'
         add_invoice(post, amount, options)
-        add_creditcard(post, creditcard)
+        add_payment_method(post, payment_method)
         add_customer_data(post, options)
 
         commit(post)
       end
 
-      def authorize(amount, creditcard, options={})
-        post = post_required_fields("Auth")
+      def authorize(amount, payment_method, options = {})
+        post = initialize_required_fields('Auth')
 
         add_invoice(post, amount, options)
-        add_creditcard(post, creditcard)
+        add_payment_method(post, payment_method)
         add_customer_data(post, options)
 
         commit(post)
       end
 
-      def capture(amount, authorization, options={})
-        post = post_required_fields("Force")
+      def capture(amount, authorization, options = {})
+        post = initialize_required_fields('Force')
 
         add_invoice(post, amount, options)
         add_reference(post, authorization)
@@ -51,8 +50,8 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
-      def refund(amount, authorization, options={})
-        post = post_required_fields("Return")
+      def refund(amount, authorization, options = {})
+        post = initialize_required_fields('Return')
 
         add_invoice(post, amount, options)
         add_reference(post, authorization)
@@ -60,8 +59,8 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
-      def void(authorization, options={})
-        post = post_required_fields("Void")
+      def void(authorization, options = {})
+        post = initialize_required_fields('Void')
 
         add_reference(post, authorization)
 
@@ -75,28 +74,80 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def store(creditcard, options = {})
+        post = initialize_required_fields('')
+        post[:transaction] = 'Create'
+        post[:CardNumber] = creditcard.number
+        post[:CustomerPaymentInfoKey] = ''
+        post[:token] = ''
+        add_payment_method(post, creditcard)
+
+        commit(post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?CardNum=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?CVNum=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?Password=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?TransitNum=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?AccountNum=)[^&]*)i, '\1[FILTERED]')
+      end
+
       private
 
-      def post_required_fields(transaction_type)
+      def add_payment_method(post, payment_method)
+        if payment_method.respond_to? :brand
+          post[:NameOnCard] = payment_method.name if payment_method.name
+          post[:ExpDate]    = expdate(payment_method)
+          post[:CardNum]    = payment_method.number
+          post[:CVNum]      = payment_method.verification_value
+        elsif payment_method.is_a?(String)
+          add_token(post, payment_method)
+        else
+          post[:CheckNum] = payment_method.number
+          post[:TransitNum] = payment_method.routing_number
+          post[:AccountNum] = payment_method.account_number
+          post[:NameOnCheck] = payment_method.name
+          post[:ExtData] = "<AccountType>#{payment_method.account_type.capitalize}</AccountType>" if payment_method.account_type
+        end
+      end
+
+      def add_token(post, payment_method)
+        payment_method = payment_method.split('|')
+        post[:ExtData] = "<Force>T</Force><CardVault><Transaction>Read</Transaction><CustomerPaymentInfoKey>#{payment_method[1]}</CustomerPaymentInfoKey><Token>#{payment_method[0]}</Token><ExpDate>#{payment_method[2]}</ExpDate></CardVault>"
+      end
+
+      def initialize_required_fields(transaction_type)
         post = {}
         post[:TransType] = transaction_type
-        post[:Amount] = ""
-        post[:PNRef] = ""
-        post[:InvNum] = ""
-        post[:CardNum] = ""
-        post[:ExpDate] = ""
-        post[:MagData] = ""
-        post[:NameOnCard] = ""
-        post[:Zip] = ""
-        post[:Street] = ""
-        post[:CVNum] = ""
-        post[:MagData] = ""
-        post[:ExtData] = ""
+        post[:Amount] = ''
+        post[:PNRef] = ''
+        post[:InvNum] = ''
+        post[:CardNum] = ''
+        post[:ExpDate] = ''
+        post[:MagData] = ''
+        post[:NameOnCard] = ''
+        post[:Zip] = ''
+        post[:Street] = ''
+        post[:CVNum] = ''
+        post[:MagData] = ''
+        post[:ExtData] = ''
+        post[:MICR] = ''
+        post[:DL] = ''
+        post[:SS] = ''
+        post[:DOB] = ''
+        post[:StateCode] = ''
+        post[:CheckType] = ''
         post
       end
 
       def add_customer_data(post, options)
-        if(billing_address = (options[:billing_address] || options[:address]))
+        if (billing_address = (options[:billing_address] || options[:address]))
           post[:Street] = billing_address[:address1]
           post[:Zip]    = billing_address[:zip]
         end
@@ -107,13 +158,6 @@ module ActiveMerchant #:nodoc:
         post[:InvNum] = options[:order_id]
       end
 
-      def add_creditcard(post, creditcard)
-        post[:NameOnCard] = creditcard.name if creditcard.name
-        post[:ExpDate]    = expdate(creditcard)
-        post[:CardNum]    = creditcard.number
-        post[:CVNum]      = creditcard.verification_value
-      end
-
       def expdate(creditcard)
         "#{format(creditcard.month, :two_digits)}#{format(creditcard.year, :two_digits)}"
       end
@@ -122,8 +166,8 @@ module ActiveMerchant #:nodoc:
         response = {}
 
         doc = Nokogiri::XML(xml)
-        doc.root.xpath("*").each do |node|
-          if (node.elements.size == 0)
+        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|
@@ -131,18 +175,17 @@ module ActiveMerchant #:nodoc:
               response[name.to_sym] = childnode.text
             end
           end
-        end unless doc.root.nil?
+        end
 
         response
       end
 
       def commit(parameters)
-        url = (test? ? test_url : live_url)
         data = post_data(parameters)
-        raw = parse(ssl_post(url, data))
+        raw = parse(ssl_post(url(parameters), data))
 
         Response.new(
-          success_from(raw[:respmsg]),
+          success_from(raw),
           message_from(raw),
           raw,
           authorization: authorization_from(raw),
@@ -150,25 +193,37 @@ module ActiveMerchant #:nodoc:
         )
       end
 
-      def success_from(result)
-        case result
-        when "Approved"
-          true
+      def url(params)
+        if params[:transaction]
+          "#{base_url}/ManageCardVault"
         else
-          false
+          action = params[:TransitNum] ? 'ProcessCheck' : 'ProcessCreditCard'
+          "#{base_url}/#{action}"
         end
       end
 
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def success_from(response)
+        response[:result] == '0'
+      end
+
       def message_from(response)
-        response[:respmsg]
+        response[:respmsg] || response[:message]
       end
 
       def authorization_from(response)
-        [response[:authcode], response[:pnref]].join("|")
+        if response[:token]
+          [response[:token], response[:customerpaymentinfokey], response[:expdate]].join('|')
+        else
+          [response[:authcode], response[:pnref]].join('|')
+        end
       end
 
       def split_authorization(authorization)
-        authcode, pnref = authorization.split("|")
+        authcode, pnref = authorization.split('|')
         [authcode, pnref]
       end
 
@@ -180,9 +235,9 @@ module ActiveMerchant #:nodoc:
 
       def post_data(post)
         {
-          :UserName => @options[:user_name],
-          :Password => @options[:password]
-        }.merge(post).collect{|k,v| "#{k}=#{CGI.escape(v.to_s)}"}.join("&")
+          UserName: @options[:user_name],
+          Password: @options[:password]
+        }.merge(post).collect { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
       end
     end
   end

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

@@ -0,0 +1,230 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CamsGateway < Gateway
+      self.live_url = 'https://secure.centralams.com/gw/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://www.centralams.com/'
+      self.display_name = 'CAMS: Central Account Management System'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '200' => STANDARD_ERROR_CODE[:card_declined],
+        '201' => STANDARD_ERROR_CODE[:card_declined],
+        '202' => STANDARD_ERROR_CODE[:card_declined],
+        '203' => STANDARD_ERROR_CODE[:card_declined],
+        '204' => STANDARD_ERROR_CODE[:card_declined],
+        '220' => STANDARD_ERROR_CODE[:card_declined],
+        '221' => STANDARD_ERROR_CODE[:card_declined],
+        '222' => STANDARD_ERROR_CODE[:incorrect_number],
+        '223' => STANDARD_ERROR_CODE[:expired_card],
+        '224' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '225' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '240' => STANDARD_ERROR_CODE[:call_issuer],
+        '250' => STANDARD_ERROR_CODE[:pickup_card],
+        '251' => STANDARD_ERROR_CODE[:pickup_card],
+        '252' => STANDARD_ERROR_CODE[:pickup_card],
+        '253' => STANDARD_ERROR_CODE[:pickup_card],
+        '260' => STANDARD_ERROR_CODE[:card_declined],
+        '261' => STANDARD_ERROR_CODE[:card_declined],
+        '262' => STANDARD_ERROR_CODE[:card_declined],
+        '263' => STANDARD_ERROR_CODE[:processing_error],
+        '264' => STANDARD_ERROR_CODE[:card_declined],
+        '300' => STANDARD_ERROR_CODE[:card_declined],
+        '400' => STANDARD_ERROR_CODE[:processing_error],
+        '410' => STANDARD_ERROR_CODE[:processing_error],
+        '411' => STANDARD_ERROR_CODE[:processing_error],
+        '420' => STANDARD_ERROR_CODE[:processing_error],
+        '421' => STANDARD_ERROR_CODE[:processing_error],
+        '430' => STANDARD_ERROR_CODE[:processing_error],
+        '440' => STANDARD_ERROR_CODE[:processing_error],
+        '441' => STANDARD_ERROR_CODE[:processing_error],
+        '460' => STANDARD_ERROR_CODE[:invalid_number],
+        '461' => STANDARD_ERROR_CODE[:processing_error],
+        '801' => STANDARD_ERROR_CODE[:processing_error],
+        '811' => STANDARD_ERROR_CODE[:processing_error],
+        '812' => STANDARD_ERROR_CODE[:processing_error],
+        '813' => STANDARD_ERROR_CODE[:processing_error],
+        '814' => STANDARD_ERROR_CODE[:processing_error],
+        '815' => STANDARD_ERROR_CODE[:processing_error],
+        '823' => STANDARD_ERROR_CODE[:processing_error],
+        '824' => STANDARD_ERROR_CODE[:processing_error],
+        '881' => STANDARD_ERROR_CODE[:processing_error],
+        '882' => STANDARD_ERROR_CODE[:processing_error],
+        '883' => STANDARD_ERROR_CODE[:processing_error],
+        '884' => STANDARD_ERROR_CODE[:card_declined],
+        '885' => STANDARD_ERROR_CODE[:card_declined],
+        '886' => STANDARD_ERROR_CODE[:card_declined],
+        '887' => STANDARD_ERROR_CODE[:processing_error],
+        '888' => STANDARD_ERROR_CODE[:processing_error],
+        '889' => STANDARD_ERROR_CODE[:processing_error],
+        '890' => STANDARD_ERROR_CODE[:processing_error],
+        '891' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        '892' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        '893' => STANDARD_ERROR_CODE[:processing_error],
+        '894' => STANDARD_ERROR_CODE[:processing_error]
+      }
+
+      def initialize(options = {})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+
+        if payment.respond_to?(:number)
+          add_payment(post, payment)
+          add_address(post, payment, options)
+        elsif payment.kind_of?(String)
+          post[:transactionid] = split_authorization(payment)[0]
+        end
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+
+        commit('auth', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, money, options)
+
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, money, options)
+        commit('refund', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_reference(post, authorization)
+        commit('void', post)
+      end
+
+      def verify(credit_card, options = {})
+        post = {}
+        add_invoice(post, 0, options)
+        add_payment(post, credit_card)
+        add_address(post, credit_card, options)
+        commit('verify', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        %w(ccnumber cvv password).each do |field|
+          transcript = transcript.gsub(%r((#{field}=)[^&]+), '\1[FILTERED]\2')
+        end
+
+        transcript
+      end
+
+      private
+
+      def add_address(post, creditcard, options = {})
+        post[:firstname] = creditcard.first_name
+        post[:lastname]  = creditcard.last_name
+
+        return unless options[:billing_address]
+
+        address = options[:billing_address]
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:city]     = address[:city]
+        post[:state]    = address[:state]
+        post[:zip]      = address[:zip]
+        post[:country]  = address[:country]
+        post[:phone]    = address[:phone]
+      end
+
+      def add_reference(post, authorization)
+        transaction_id, authcode = split_authorization(authorization)
+        post['transactionid'] = transaction_id
+        post['authcode']      = authcode
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || default_currency)
+      end
+
+      def add_payment(post, payment)
+        post[:ccnumber] = payment.number
+        post[:ccexp] = "#{payment.month.to_s.rjust(2, '0')}#{payment.year.to_s[-2..-1]}"
+        post[:cvv] = payment.verification_value
+      end
+
+      def parse(body)
+        kvs = body.split('&')
+
+        kvs.inject({}) { |h, kv|
+          k, v = kv.split('=')
+          h[k] = v
+          h
+        }
+      end
+
+      def commit(action, parameters)
+        url = live_url
+        parameters[:type] = action
+
+        response_body = ssl_post(url, post_data(parameters))
+        response = parse(response_body)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response['response_code'] == '100'
+      end
+
+      def message_from(response)
+        response['responsetext']
+      end
+
+      def authorization_from(response)
+        [response['transactionid'], response['authcode']].join('#')
+      end
+
+      def split_authorization(authorization)
+        transaction_id, authcode = authorization.split('#')
+        [transaction_id, authcode]
+      end
+
+      def post_data(parameters = {})
+        parameters[:password] = @options[:password]
+        parameters[:username] = @options[:username]
+
+        parameters.collect { |k, v| "#{k}=#{v}" }.join('&')
+      end
+
+      def error_code_from(response)
+        STANDARD_ERROR_CODE_MAPPING[response['response_code']]
+      end
+    end
+  end
+end