active_accountability_merchant 1.97.1

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

@@ -0,0 +1,194 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class GlobalTransportGateway < Gateway
+      self.test_url = 'https://certapia.globalpay.com/GlobalPay/transact.asmx/ProcessCreditCard'
+      self.live_url = 'https://api.globalpay.com/GlobalPay/transact.asmx/ProcessCreditCard'
+
+      self.supported_countries = %w(CA PR US)
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+      self.homepage_url = 'https://www.globalpaymentsinc.com'
+      self.display_name = 'Global Transport'
+
+      # Public: Create a new Global Transport gateway.
+      #
+      # options - A hash of options:
+      #           :global_user_name - Your Global user name
+      #           :global_password  - Your Global password
+      #           :term_type        - 3 character field assigned by Global Transport after
+      #                             - your application is certified.
+      def initialize(options={})
+        requires!(options, :global_user_name, :global_password, :term_type)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+
+        commit('Sale', post, options)
+      end
+
+      def authorize(money, payment_method, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+
+        commit('Auth', post, options)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_auth(post, authorization)
+
+        commit('Force', post, options)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_auth(post, authorization)
+
+        commit('Return', post, options)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_auth(post, authorization)
+
+        commit('Void', post, options)
+      end
+
+      def verify(payment_method, options={})
+        post = {}
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+
+        commit('CardVerify', post, options)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?CardNum=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?CVNum=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?GlobalPassword=)[^&]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def add_address(post, options)
+        if address = (options[:billing_address] || options[:address])
+          post[:Street] = address[:address1]
+          post[:Zip] = address[:zip]
+        end
+      end
+
+      def add_auth(post, authorization)
+        post[:PNRef] = authorization
+      end
+
+      def add_invoice(post, money, options)
+        currency = (options[:currency] || currency(money))
+
+        post[:Amount] = localized_amount(money, currency)
+        post[:InvNum] = truncate(options[:order_id], 16)
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:CardNum] = payment_method.number
+        post[:ExpDate] = expdate(payment_method)
+        post[:NameOnCard] = payment_method.name
+        post[:CVNum] = payment_method.verification_value
+      end
+
+      def parse(body)
+        response = {}
+
+        Nokogiri::XML(body).root.xpath('*').each do |node|
+          response[node.name.downcase.to_sym] = node.text
+        end
+
+        ext_data = Nokogiri::HTML.parse(response[:extdata])
+        response[:approved_amount] = ext_data.xpath('//approvedamount').text
+        response[:balance_due] = ext_data.xpath('//balancedue').text
+
+        response
+      end
+
+      def commit(action, parameters, options)
+        raw = parse(ssl_post(url, post_data(action, parameters, options)))
+        Response.new(
+          success_from(raw),
+          message_from(raw),
+          raw,
+          authorization: authorization_from(raw),
+          test: test?,
+          avs_result: avs_from(raw),
+          cvv_result: cvv_from(raw)
+        )
+      end
+
+      def post_data(action, params, options)
+        post = default_params
+        post[:GlobalUserName] = @options[:global_user_name]
+        post[:GlobalPassword] = @options[:global_password]
+        post[:TransType] = action
+        post[:ExtData] = "<TermType>#{@options[:term_type]}</TermType>"
+
+        post.merge(params).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+
+      def url
+        (test? ? test_url : live_url)
+      end
+
+      def success_from(response)
+        response[:result] == '0' || response[:result] == '200'
+      end
+
+      def message_from(response)
+        response[:respmsg]
+      end
+
+      def authorization_from(response)
+        response[:pnref]
+      end
+
+      def avs_from(response)
+        { code: response[:getavsresult] }
+      end
+
+      def cvv_from(response)
+        response[:getcvresult]
+      end
+
+      def default_params
+        {
+          CardNum: '',
+          ExpDate: '',
+          NameOnCard: '',
+          Amount: '',
+          PNRef: '',
+          Zip: '',
+          Street: '',
+          CVNum: '',
+          MagData: '',
+          InvNum: '',
+          ExtData: ''
+        }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class HdfcGateway < Gateway
+      self.display_name = 'HDFC'
+      self.homepage_url = 'http://www.hdfcbank.com/sme/sme-details/merchant-services/guzh6m0i'
+
+      self.test_url = 'https://securepgtest.fssnet.co.in/pgway/servlet/'
+      self.live_url = 'https://securepg.fssnet.co.in/pgway/servlet/'
+
+      self.supported_countries = ['IN']
+      self.default_currency = 'INR'
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :discover, :diners_club]
+
+      def initialize(options={})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit('purchase', post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit('authorize', post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit('capture', post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit('refund', post)
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new { |h, k| raise ArgumentError.new("Unsupported currency for HDFC: #{k}") }
+      CURRENCY_CODES['AED'] = '784'
+      CURRENCY_CODES['AUD'] = '036'
+      CURRENCY_CODES['CAD'] = '124'
+      CURRENCY_CODES['EUR'] = '978'
+      CURRENCY_CODES['GBP'] = '826'
+      CURRENCY_CODES['INR'] = '356'
+      CURRENCY_CODES['OMR'] = '512'
+      CURRENCY_CODES['QAR'] = '634'
+      CURRENCY_CODES['SGD'] = '702'
+      CURRENCY_CODES['USD'] = '840'
+
+      def add_invoice(post, amount, options)
+        post[:amt] = amount(amount)
+        post[:currencycode] = CURRENCY_CODES[options[:currency] || currency(amount)]
+        post[:trackid] = escape(options[:order_id], 40) if options[:order_id]
+        post[:udf1] = escape(options[:description]) if options[:description]
+        post[:eci] = options[:eci] if options[:eci]
+      end
+
+      def add_customer_data(post, options)
+        post[:udf2] = escape(options[:email]) if options[:email]
+        if address = (options[:billing_address] || options[:address])
+          post[:udf3] = escape(address[:phone]) if address[:phone]
+          post[:udf4] = escape(<<EOA)
+#{address[:name]}
+#{address[:company]}
+#{address[:address1]}
+#{address[:address2]}
+#{address[:city]} #{address[:state]} #{address[:zip]}
+#{address[:country]}
+EOA
+        end
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:member] = escape(payment_method.name, 30)
+        post[:card] = escape(payment_method.number)
+        post[:cvv2] = escape(payment_method.verification_value)
+        post[:expyear] = format(payment_method.year, :four_digits)
+        post[:expmonth] = format(payment_method.month, :two_digits)
+      end
+
+      def add_reference(post, authorization)
+        tranid, member = split_authorization(authorization)
+        post[:transid] = tranid
+        post[:member] = member
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML.fragment(fix_xml(xml))
+        doc.children.each do |node|
+          if node.text?
+            next
+          elsif 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
+
+        response
+      end
+
+      def fix_xml(xml)
+        xml.gsub(/&(?!(?:amp|quot|apos|lt|gt);)/, '&amp;')
+      end
+
+      ACTIONS = {
+        'purchase' => '1',
+        'refund' => '2',
+        'authorize' => '4',
+        'capture' => '5',
+      }
+
+      def commit(action, post)
+        post[:id] = @options[:login]
+        post[:password] = @options[:password]
+        post[:action] = ACTIONS[action] if ACTIONS[action]
+
+        raw = parse(ssl_post(url(action), build_request(post)))
+
+        succeeded = success_from(raw[:result])
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          :authorization => authorization_from(post, raw),
+          :test => test?
+        )
+      end
+
+      def build_request(post)
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        post.each do |field, value|
+          xml.tag!(field, value)
+        end
+        xml.target!
+      end
+
+      def url(action)
+        endpoint = 'TranPortalXMLServlet'
+        (test? ? test_url : live_url) + endpoint
+      end
+
+      def success_from(result)
+        case result
+        when 'CAPTURED', 'APPROVED', 'NOT ENROLLED', 'ENROLLED'
+          true
+        else
+          false
+        end
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          'Succeeded'
+        else
+          (response[:error_text] || response[:result] || 'Unable to read error message').split('-').last
+        end
+      end
+
+      def authorization_from(request, response)
+        [response[:tranid], request[:member]].join('|')
+      end
+
+      def split_authorization(authorization)
+        tranid, member = authorization.split('|')
+        [tranid, member]
+      end
+
+      def escape(string, max_length=250)
+        return '' unless string
+        if max_length
+          string = string[0...max_length]
+        end
+        string.gsub(/[^A-Za-z0-9 \-_@\.\n]/, '')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,350 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class HpsGateway < Gateway
+      self.live_url = 'https://posgateway.secureexchange.net/Hps.Exchange.PosGateway/PosGatewayService.asmx?wsdl'
+      self.test_url = 'https://posgateway.cert.secureexchange.net/Hps.Exchange.PosGateway/PosGatewayService.asmx?wsdl'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jbc, :diners_club]
+
+      self.homepage_url = 'http://developer.heartlandpaymentsystems.com/SecureSubmit/'
+      self.display_name = 'Heartland Payment Systems'
+
+      self.money_format = :dollars
+
+      PAYMENT_DATA_SOURCE_MAPPING = {
+        apple_pay:        'ApplePay',
+        master:           'MasterCard 3DSecure',
+        visa:             'Visa 3DSecure',
+        american_express: 'AMEX 3DSecure',
+        discover:         'Discover 3DSecure',
+      }
+
+      def initialize(options={})
+        requires!(options, :secret_api_key)
+        super
+      end
+
+      def authorize(money, card_or_token, options={})
+        commit('CreditAuth') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_customer_data(xml, card_or_token, options)
+          add_details(xml, options)
+          add_descriptor_name(xml, options)
+          add_payment(xml, card_or_token, options)
+          add_three_d_secure(xml, card_or_token, options)
+        end
+      end
+
+      def capture(money, transaction_id, options={})
+        commit('CreditAddToBatch') do |xml|
+          add_amount(xml, money)
+          add_reference(xml, transaction_id)
+        end
+      end
+
+      def purchase(money, card_or_token, options={})
+        commit('CreditSale') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_customer_data(xml, card_or_token, options)
+          add_details(xml, options)
+          add_descriptor_name(xml, options)
+          add_payment(xml, card_or_token, options)
+          add_three_d_secure(xml, card_or_token, options)
+        end
+      end
+
+      def refund(money, transaction_id, options={})
+        commit('CreditReturn') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_reference(xml, transaction_id)
+          add_customer_data(xml, transaction_id, options)
+          add_details(xml, options)
+        end
+      end
+
+      def verify(card_or_token, options={})
+        commit('CreditAccountVerify') do |xml|
+          add_customer_data(xml, card_or_token, options)
+          add_descriptor_name(xml, options)
+          add_payment(xml, card_or_token, options)
+        end
+      end
+
+      def void(transaction_id, options={})
+        commit('CreditVoid') do |xml|
+          add_reference(xml, transaction_id)
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<hps:CardNbr>)[^<]*(<\/hps:CardNbr>))i, '\1[FILTERED]\2').
+          gsub(%r((<hps:CVV2>)[^<]*(<\/hps:CVV2>))i, '\1[FILTERED]\2').
+          gsub(%r((<hps:SecretAPIKey>)[^<]*(<\/hps:SecretAPIKey>))i, '\1[FILTERED]\2').
+          gsub(%r((<hps:PaymentData>)[^<]*(<\/hps:PaymentData>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_reference(xml, transaction_id)
+        xml.hps :GatewayTxnId, transaction_id
+      end
+
+      def add_amount(xml, money)
+        xml.hps :Amt, amount(money) if money
+      end
+
+      def add_customer_data(xml, credit_card, options)
+        xml.hps :CardHolderData do
+          if credit_card.respond_to?(:number)
+            xml.hps :CardHolderFirstName, credit_card.first_name if credit_card.first_name
+            xml.hps :CardHolderLastName, credit_card.last_name if credit_card.last_name
+          end
+
+          xml.hps :CardHolderEmail, options[:email] if options[:email]
+          xml.hps :CardHolderPhone, options[:phone] if options[:phone]
+
+          if(billing_address = (options[:billing_address] || options[:address]))
+            xml.hps :CardHolderAddr, billing_address[:address1] if billing_address[:address1]
+            xml.hps :CardHolderCity, billing_address[:city] if billing_address[:city]
+            xml.hps :CardHolderState, billing_address[:state] if billing_address[:state]
+            xml.hps :CardHolderZip, billing_address[:zip] if billing_address[:zip]
+          end
+        end
+      end
+
+      def add_payment(xml, card_or_token, options)
+        xml.hps :CardData do
+          if card_or_token.respond_to?(:number)
+            if card_or_token.track_data
+              xml.tag!('hps:TrackData', 'method'=>'swipe') do
+                xml.text! card_or_token.track_data
+              end
+              if options[:encryption_type]
+                xml.hps :EncryptionData do
+                  xml.hps :Version, options[:encryption_type]
+                  if options[:encryption_type] == '02'
+                    xml.hps :EncryptedTrackNumber, options[:encrypted_track_number]
+                    xml.hps :KTB, options[:ktb]
+                  end
+                end
+              end
+            else
+              xml.hps :ManualEntry do
+                xml.hps :CardNbr, card_or_token.number
+                xml.hps :ExpMonth, card_or_token.month
+                xml.hps :ExpYear, card_or_token.year
+                xml.hps :CVV2, card_or_token.verification_value if card_or_token.verification_value
+                xml.hps :CardPresent, 'N'
+                xml.hps :ReaderPresent, 'N'
+              end
+            end
+          else
+            xml.hps :TokenData do
+              xml.hps :TokenValue, card_or_token
+            end
+          end
+          xml.hps :TokenRequest, (options[:store] ? 'Y' : 'N')
+        end
+      end
+
+      def add_details(xml, options)
+        xml.hps :AdditionalTxnFields do
+          xml.hps :Description, options[:description] if options[:description]
+          xml.hps :InvoiceNbr, options[:order_id] if options[:order_id]
+          xml.hps :CustomerID, options[:customer_id] if options[:customer_id]
+        end
+      end
+
+      def add_allow_dup(xml)
+        xml.hps :AllowDup, 'Y'
+      end
+
+      def add_descriptor_name(xml, options)
+        xml.hps :TxnDescriptor, options[:descriptor_name] if options[:descriptor_name]
+      end
+
+      def add_three_d_secure(xml, card_or_token, options)
+        if card_or_token.is_a?(NetworkTokenizationCreditCard)
+          build_three_d_secure(xml, {
+            source: card_or_token.source,
+            cavv: card_or_token.payment_cryptogram,
+            eci: card_or_token.eci,
+            xid: card_or_token.transaction_id,
+          })
+        elsif options[:three_d_secure]
+          options[:three_d_secure][:source] ||= card_brand(card_or_token)
+          build_three_d_secure(xml, options[:three_d_secure])
+        end
+      end
+
+      def build_three_d_secure(xml, three_d_secure)
+        # PaymentDataSource is required when supplying the SecureECommerce data group,
+        # and the gateway currently only allows the values within the mapping
+        return unless PAYMENT_DATA_SOURCE_MAPPING[three_d_secure[:source].to_sym]
+
+        xml.hps :SecureECommerce do
+          xml.hps :PaymentDataSource, PAYMENT_DATA_SOURCE_MAPPING[three_d_secure[:source].to_sym]
+          xml.hps :TypeOfPaymentData, '3DSecure' # Only type currently supported
+          xml.hps :PaymentData, three_d_secure[:cavv] if three_d_secure[:cavv]
+          # the gateway only allows a single character for the ECI
+          xml.hps :ECommerceIndicator, strip_leading_zero(three_d_secure[:eci]) if three_d_secure[:eci]
+          xml.hps :XID, three_d_secure[:xid] if three_d_secure[:xid]
+        end
+      end
+
+      def strip_leading_zero(value)
+        return value unless value[0] == '0'
+        value[1, 1]
+      end
+
+      def build_request(action)
+        xml = Builder::XmlMarkup.new(encoding: 'UTF-8')
+        xml.instruct!(:xml, encoding: 'UTF-8')
+        xml.SOAP :Envelope, {
+            'xmlns:SOAP' => 'http://schemas.xmlsoap.org/soap/envelope/',
+            'xmlns:hps' => 'http://Hps.Exchange.PosGateway' } do
+          xml.SOAP :Body do
+            xml.hps :PosRequest do
+              xml.hps 'Ver1.0'.to_sym do
+                xml.hps :Header do
+                  xml.hps :SecretAPIKey, @options[:secret_api_key]
+                  xml.hps :DeveloperID, @options[:developer_id] if @options[:developer_id]
+                  xml.hps :VersionNbr, @options[:version_number] if @options[:version_number]
+                  xml.hps :SiteTrace, @options[:site_trace] if @options[:site_trace]
+                end
+                xml.hps :Transaction do
+                  xml.hps action.to_sym do
+                    if %w(CreditVoid CreditAddToBatch).include?(action)
+                      yield(xml)
+                    else
+                      xml.hps :Block1 do
+                        yield(xml)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def parse(raw)
+        response = {}
+
+        doc = Nokogiri::XML(raw)
+        doc.remove_namespaces!
+        if(header = doc.xpath('//Header').first)
+          header.elements.each do |node|
+            if node.elements.size == 0
+              response[node.name] = node.text
+            else
+              node.elements.each do |childnode|
+                response[childnode.name] = childnode.text
+              end
+            end
+          end
+        end
+        if(transaction = doc.xpath('//Transaction/*[1]').first)
+          transaction.elements.each do |node|
+            response[node.name] = node.text
+          end
+        end
+        if(fault = doc.xpath('//Fault/Reason/Text').first)
+          response['Fault'] = fault.text
+        end
+
+        response
+      end
+
+      def commit(action, &request)
+        data = build_request(action, &request)
+
+        response = begin
+          parse(ssl_post((test? ? test_url : live_url), data, 'Content-Type' => 'text/xml'))
+        rescue ResponseError => e
+          parse(e.response.body)
+        end
+
+        ActiveMerchant::Billing::Response.new(
+          successful?(response),
+          message_from(response),
+          response,
+          test: test?,
+          authorization: authorization_from(response),
+          avs_result: {
+            code: response['AVSRsltCode'],
+            message: response['AVSRsltText']
+          },
+          cvv_result: response['CVVRsltCode']
+        )
+      end
+
+      def successful?(response)
+        (
+          (response['GatewayRspCode'] == '0') &&
+          ((response['RspCode'] || '00') == '00' || response['RspCode'] == '85')
+        )
+      end
+
+      def message_from(response)
+        if(response['Fault'])
+          response['Fault']
+        elsif(response['GatewayRspCode'] == '0')
+          if(response['RspCode'] != '00' && response['RspCode'] != '85')
+            issuer_message(response['RspCode'])
+          else
+            response['GatewayRspMsg']
+          end
+        else
+          (GATEWAY_MESSAGES[response['GatewayRspCode']] || response['GatewayRspMsg'])
+        end
+      end
+
+      def authorization_from(response)
+        response['GatewayTxnId']
+      end
+
+      def test?
+        @options[:secret_api_key]&.include?('_cert_')
+      end
+
+      ISSUER_MESSAGES = {
+        '13' => 'Must be greater than or equal 0.',
+        '14' => 'The card number is incorrect.',
+        '54' => 'The card has expired.',
+        '55' => 'The 4-digit pin is invalid.',
+        '75' => 'Maximum number of pin retries exceeded.',
+        '80' => 'Card expiration date is invalid.',
+        '86' => "Can't verify card pin number."
+      }
+      def issuer_message(code)
+        return 'The card was declined.' if %w(02 03 04 05 41 43 44 51 56 61 62 63 65 78).include?(code)
+        return 'An error occurred while processing the card.' if %w(06 07 12 15 19 12 52 53 57 58 76 77 91 96 EC).include?(code)
+        return "The card's security code is incorrect." if %w(EB N7).include?(code)
+        ISSUER_MESSAGES[code]
+      end
+
+      GATEWAY_MESSAGES = {
+        '-2' => 'Authentication error. Please double check your service configuration.',
+        '12' => 'Invalid CPC data.',
+        '13' => 'Invalid card data.',
+        '14' => 'The card number is not a valid credit card number.',
+        '30' => 'Gateway timed out.'
+      }
+    end
+  end
+end