activemerchant 1.38.0 → 1.78.0

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

@@ -0,0 +1,175 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class IppGateway < Gateway
+      self.live_url = 'https://www.ippayments.com.au/interface/api/dts.asmx'
+      self.test_url = 'https://demo.ippayments.com.au/interface/api/dts.asmx'
+
+      self.supported_countries = ['AU']
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
+
+      self.homepage_url = 'http://www.ippayments.com.au/'
+      self.display_name = 'IPP'
+
+      self.money_format = :cents
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        "05" => STANDARD_ERROR_CODE[:card_declined],
+        "06" => STANDARD_ERROR_CODE[:processing_error],
+        "14" => STANDARD_ERROR_CODE[:invalid_number],
+        "54" => STANDARD_ERROR_CODE[:expired_card],
+      }
+
+      def initialize(options={})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        commit("SubmitSinglePayment") do |xml|
+          xml.Transaction do
+            xml.CustRef options[:order_id]
+            add_amount(xml, money)
+            xml.TrnType "1"
+            add_credit_card(xml, payment)
+            add_credentials(xml)
+            xml.TrnSource options[:ip]
+          end
+        end
+      end
+
+      def authorize(money, payment, options={})
+        commit("SubmitSinglePayment") do |xml|
+          xml.Transaction do
+            xml.CustRef options[:order_id]
+            add_amount(xml, money)
+            xml.TrnType "2"
+            add_credit_card(xml, payment)
+            add_credentials(xml)
+            xml.TrnSource options[:ip]
+          end
+        end
+      end
+
+      def capture(money, authorization, options={})
+        commit("SubmitSingleCapture") do |xml|
+          xml.Capture do
+            xml.Receipt authorization
+            add_amount(xml, money)
+            add_credentials(xml)
+          end
+        end
+      end
+
+      def refund(money, authorization, options={})
+        commit("SubmitSingleRefund") do |xml|
+          xml.Refund do
+            xml.Receipt authorization
+            add_amount(xml, money)
+            add_credentials(xml)
+          end
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<CardNumber>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<CVN>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<Password>)[^<]+(<))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_credentials(xml)
+        xml.Security do
+          xml.UserName @options[:username]
+          xml.Password @options[:password]
+        end
+      end
+
+      def add_amount(xml, money)
+        xml.Amount amount(money)
+      end
+
+      def add_credit_card(xml, payment)
+        xml.CreditCard :Registered => "False" do
+          xml.CardNumber payment.number
+          xml.ExpM format(payment.month, :two_digits)
+          xml.ExpY format(payment.year, :four_digits)
+          xml.CVN payment.verification_value
+          xml.CardHolderName payment.name
+        end
+      end
+
+      def parse(body)
+        element = Nokogiri::XML(body).root.first_element_child.first_element_child
+
+        response = {}
+        doc = Nokogiri::XML(element)
+        doc.root.elements.each do |e|
+          response[e.name.underscore.to_sym] = e.inner_text
+        end
+        response
+      end
+
+      def commit(action, &block)
+        headers = {
+          "Content-Type" => "text/xml; charset=utf-8",
+          "SOAPAction" => "http://www.ippayments.com.au/interface/api/dts/#{action}",
+        }
+        response = parse(ssl_post(commit_url, new_submit_xml(action, &block), headers))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          error_code: error_code_from(response),
+          test: test?,
+        )
+      end
+
+      def new_submit_xml(action)
+        xml = Builder::XmlMarkup.new(indent: 2)
+        xml.instruct!
+        xml.soap :Envelope, "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/" do
+          xml.soap :Body do
+            xml.__send__(action, "xmlns" => "http://www.ippayments.com.au/interface/api/dts") do
+              xml.trnXML do
+                inner_xml = Builder::XmlMarkup.new(indent: 2)
+                yield(inner_xml)
+                xml.cdata!(inner_xml.target!)
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def commit_url
+        (test? ? test_url : live_url)
+      end
+
+      def success_from(response)
+        (response[:response_code] == "0")
+      end
+
+      def error_code_from(response)
+        STANDARD_ERROR_CODE_MAPPING[response[:declined_code]]
+      end
+
+      def message_from(response)
+        response[:declined_message]
+      end
+
+      def authorization_from(response)
+        response[:receipt]
+      end
+    end
+  end
+end

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

@@ -24,13 +24,202 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'Iridium'
 
       CURRENCY_CODES = {
+        "AED" => '784',
+        "AFN" => '971',
+        "ALL" => '008',
+        "AMD" => '051',
+        "ANG" => '532',
+        "AOA" => '973',
+        "ARS" => '032',
         "AUD" => '036',
+        "AWG" => '533',
+        "AZN" => '944',
+        "BAM" => '977',
+        "BBD" => '052',
+        "BDT" => '050',
+        "BGN" => '975',
+        "BHD" => '048',
+        "BIF" => '108',
+        "BMD" => '060',
+        "BND" => '096',
+        "BOB" => '068',
+        "BOV" => '984',
+        "BRL" => '986',
+        "BSD" => '044',
+        "BTN" => '064',
+        "BWP" => '072',
+        "BYR" => '974',
+        "BZD" => '084',
         "CAD" => '124',
+        "CDF" => '976',
+        "CHE" => '947',
+        "CHF" => '756',
+        "CHW" => '948',
+        "CLF" => '990',
+        "CLP" => '152',
+        "CNY" => '156',
+        "COP" => '170',
+        "COU" => '970',
+        "CRC" => '188',
+        "CUP" => '192',
+        "CVE" => '132',
+        "CYP" => '196',
+        "CZK" => '203',
+        "DJF" => '262',
+        "DKK" => '208',
+        "DOP" => '214',
+        "DZD" => '012',
+        "EEK" => '233',
+        "EGP" => '818',
+        "ERN" => '232',
+        "ETB" => '230',
         "EUR" => '978',
+        "FJD" => '242',
+        "FKP" => '238',
         "GBP" => '826',
+        "GEL" => '981',
+        "GHS" => '288',
+        "GIP" => '292',
+        "GMD" => '270',
+        "GNF" => '324',
+        "GTQ" => '320',
+        "GYD" => '328',
+        "HKD" => '344',
+        "HNL" => '340',
+        "HRK" => '191',
+        "HTG" => '332',
+        "HUF" => '348',
+        "IDR" => '360',
+        "ILS" => '376',
+        "INR" => '356',
+        "IQD" => '368',
+        "IRR" => '364',
+        "ISK" => '352',
+        "JMD" => '388',
+        "JOD" => '400',
+        "JPY" => '392',
+        "KES" => '404',
+        "KGS" => '417',
+        "KHR" => '116',
+        "KMF" => '174',
+        "KPW" => '408',
+        "KRW" => '410',
+        "KWD" => '414',
+        "KYD" => '136',
+        "KZT" => '398',
+        "LAK" => '418',
+        "LBP" => '422',
+        "LKR" => '144',
+        "LRD" => '430',
+        "LSL" => '426',
+        "LTL" => '440',
+        "LVL" => '428',
+        "LYD" => '434',
+        "MAD" => '504',
+        "MDL" => '498',
+        "MGA" => '969',
+        "MKD" => '807',
+        "MMK" => '104',
+        "MNT" => '496',
+        "MOP" => '446',
+        "MRO" => '478',
+        "MTL" => '470',
+        "MUR" => '480',
+        "MVR" => '462',
+        "MWK" => '454',
         "MXN" => '484',
+        "MXV" => '979',
+        "MYR" => '458',
+        "MZN" => '943',
+        "NAD" => '516',
+        "NGN" => '566',
+        "NIO" => '558',
+        "NOK" => '578',
+        "NPR" => '524',
         "NZD" => '554',
+        "OMR" => '512',
+        "PAB" => '590',
+        "PEN" => '604',
+        "PGK" => '598',
+        "PHP" => '608',
+        "PKR" => '586',
+        "PLN" => '985',
+        "PYG" => '600',
+        "QAR" => '634',
+        "ROL" => '642',
+        "RON" => '946',
+        "RSD" => '941',
+        "RUB" => '643',
+        "RWF" => '646',
+        "SAR" => '682',
+        "SBD" => '090',
+        "SCR" => '690',
+        "SDG" => '938',
+        "SEK" => '752',
+        "SGD" => '702',
+        "SHP" => '654',
+        "SKK" => '703',
+        "SLL" => '694',
+        "SOS" => '706',
+        "SRD" => '968',
+        "STD" => '678',
+        "SYP" => '760',
+        "SZL" => '748',
+        "THB" => '764',
+        "TJS" => '972',
+        "TMM" => '795',
+        "TND" => '788',
+        "TOP" => '776',
+        "TRY" => '949',
+        "TTD" => '780',
+        "TWD" => '901',
+        "TZS" => '834',
+        "UAH" => '980',
+        "UGX" => '800',
         "USD" => '840',
+        "USN" => '997',
+        "USS" => '998',
+        "UYU" => '858',
+        "UZS" => '860',
+        "VEB" => '862',
+        "VND" => '704',
+        "VUV" => '548',
+        "WST" => '882',
+        "XAF" => '950',
+        "XAG" => '961',
+        "XAU" => '959',
+        "XBA" => '955',
+        "XBB" => '956',
+        "XBC" => '957',
+        "XBD" => '958',
+        "XCD" => '951',
+        "XDR" => '960',
+        "XOF" => '952',
+        "XPD" => '964',
+        "XPF" => '953',
+        "XPT" => '962',
+        "XTS" => '963',
+        "XXX" => '999',
+        "YER" => '886',
+        "ZAR" => '710',
+        "ZMK" => '894',
+        "ZWD" => '716',
+      }
+
+      AVS_CODE = {
+        "PASSED" => "Y",
+        "FAILED" => "N",
+        "PARTIAL" => "X",
+        "NOT_CHECKED" => "X",
+        "UNKNOWN" => "X"
+      }
+
+      CVV_CODE = {
+        "PASSED" => "M",
+        "FAILED" => "N",
+        "PARTIAL" => "I",
+        "NOT_CHECKED" => "P",
+        "UNKNOWN" => "U"
       }
 
       def initialize(options = {})
@@ -63,7 +252,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, authorization, options={})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, authorization, options)
       end
 
@@ -75,6 +264,17 @@ module ActiveMerchant #:nodoc:
         commit(build_reference_request('VOID', nil, authorization, options), options)
       end
 
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((<CardNumber>)\d+(</CardNumber>)), '\1[FILTERED]\2').
+          gsub(%r((<CV2>)\d+(</CV2>)), '\1[FILTERED]\2')
+      end
+
       private
 
       def build_purchase_request(type, money, creditcard, options)
@@ -88,7 +288,7 @@ module ActiveMerchant #:nodoc:
 
       def build_reference_request(type, money, authorization, options)
         options.merge!(:action => 'CrossReferenceTransaction')
-        order_id, cross_reference, auth_id = authorization.split(";")
+        order_id, cross_reference, _ = authorization.split(";")
         build_request(options) do |xml|
           if money
             details = {'CurrencyCode' => currency_code(options[:currency] || default_currency), 'Amount' => amount(money)}
@@ -177,7 +377,7 @@ module ActiveMerchant #:nodoc:
       def commit(request, options)
         requires!(options, :action)
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request,
-                              {"SOAPAction" => "https://www.thepaymentgateway.net/#{options[:action]}",
+                              {"SOAPAction" => "https://www.thepaymentgateway.net/" + options[:action],
                                "Content-Type" => "text/xml; charset=utf-8" }))
 
         success = response[:transaction_result][:status_code] == "0"
@@ -186,7 +386,13 @@ module ActiveMerchant #:nodoc:
 
         Response.new(success, message, response,
           :test => test?,
-          :authorization => authorization)
+          :authorization => authorization,
+          :avs_result => {
+            :street_match => AVS_CODE[ response[:transaction_output_data][:address_numeric_check_result] ],
+            :postal_match => AVS_CODE[ response[:transaction_output_data][:post_code_check_result] ],
+          },
+          :cvv_result => CVV_CODE[ response[:transaction_output_data][:cv2_check_result] ]
+        )
       end
 
       def parse(xml)

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

@@ -0,0 +1,251 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class IveriGateway < Gateway
+      self.live_url = self.test_url = 'https://portal.nedsecure.co.za/iVeriWebService/Service.asmx'
+
+      self.supported_countries = ['US', 'ZA', 'GB']
+      self.default_currency = 'ZAR'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express]
+
+      self.homepage_url = 'http://www.iveri.com'
+      self.display_name = 'iVeri'
+
+      def initialize(options={})
+        requires!(options, :app_id, :cert_id)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        post = build_vxml_request('Debit', options) do |xml|
+          add_auth_purchase_params(xml, money, payment_method, options)
+        end
+
+        commit(post)
+      end
+
+      def authorize(money, payment_method, options={})
+        post = build_vxml_request('Authorisation', options) do |xml|
+          add_auth_purchase_params(xml, money, payment_method, options)
+        end
+
+        commit(post)
+      end
+
+      def capture(money, authorization, options={})
+        post = build_vxml_request('Debit', options) do |xml|
+          add_authorization(xml, authorization, options)
+        end
+
+        commit(post)
+      end
+
+      def refund(money, authorization, options={})
+        post = build_vxml_request('Credit', options) do |xml|
+          add_amount(xml, money, options)
+          add_authorization(xml, authorization, options)
+        end
+
+        commit(post)
+      end
+
+      def void(authorization, options={})
+        post = build_vxml_request('Void', options) do |xml|
+          add_authorization(xml, authorization, options)
+        end
+
+        commit(post)
+      end
+
+      def verify(credit_card, options={})
+        authorize(0, credit_card, options)
+      end
+
+      def verify_credentials
+        void = void('', options)
+        return true if void.message ==  'Missing OriginalMerchantTrace'
+        false
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((CertificateID=\\\")[^\\]*), '\1[FILTERED]').
+          gsub(%r((&lt;PAN&gt;)[^&]*), '\1[FILTERED]').
+          gsub(%r((&lt;CardSecurityCode&gt;)[^&]*), '\1[FILTERED]')
+      end
+
+      private
+
+      def build_xml_envelope(vxml)
+        builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml[:soap].Envelope '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/' do
+            xml[:soap].Body do
+              xml.Execute 'xmlns' => 'http://iveri.com/' do
+                xml.validateRequest 'true'
+                xml.protocol 'V_XML'
+                xml.protocolVersion '2.0'
+                xml.request vxml
+              end
+            end
+          end
+        end
+
+        builder.to_xml
+      end
+
+      def build_vxml_request(action, options)
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.V_XML('Version' => '2.0', 'CertificateID' => @options[:cert_id], 'Direction' => 'Request') do
+            xml.Transaction('ApplicationID' => @options[:app_id], 'Command' => action, 'Mode' => mode) do
+              yield(xml)
+            end
+          end
+        end
+
+        builder.doc.root.to_xml
+      end
+
+      def add_auth_purchase_params(post, money, payment_method, options)
+        add_card_holder_authentication(post, options)
+        add_amount(post, money, options)
+        add_electronic_commerce_indicator(post, options)
+        add_payment_method(post, payment_method, options)
+      end
+
+      def add_amount(post, money, options)
+        post.Amount(amount(money))
+        post.Currency(options[:currency] || default_currency)
+      end
+
+      def add_electronic_commerce_indicator(post, options)
+        post.ElectronicCommerceIndicator(options[:eci]) if options[:eci]
+      end
+
+      def add_authorization(post, authorization, options)
+        post.MerchantReference(split_auth(authorization)[2])
+        post.TransactionIndex(split_auth(authorization)[1])
+        post.OriginalRequestID(split_auth(authorization)[0])
+      end
+
+      def add_payment_method(post, payment_method, options)
+        post.ExpiryDate("#{format(payment_method.month, :two_digits)}#{payment_method.year}")
+        add_new_reference(post, options)
+        post.CardSecurityCode(payment_method.verification_value)
+        post.PAN(payment_method.number)
+      end
+
+      def add_new_reference(post, options)
+        post.MerchantReference(options[:order_id] || generate_unique_id)
+      end
+
+      def add_card_holder_authentication(post, options)
+        post.CardHolderAuthenticationID(options[:xid]) if options[:xid]
+        post.CardHolderAuthenticationData(options[:cavv]) if options[:cavv]
+      end
+
+      def commit(post)
+        raw_response = begin
+          ssl_post(live_url, build_xml_envelope(post), headers(post))
+        rescue ActiveMerchant::ResponseError => e
+          e.response.body
+        end
+
+        parsed = parse(raw_response)
+        succeeded = success_from(parsed)
+
+        Response.new(
+          succeeded,
+          message_from(parsed, succeeded),
+          parsed,
+          authorization: authorization_from(parsed),
+          error_code: error_code_from(parsed, succeeded),
+          test: test?
+        )
+      end
+
+      def mode
+        test? ? 'Test' : 'Live'
+      end
+
+      def headers(post)
+        {
+          "Content-Type" => "text/xml; charset=utf-8",
+          "Content-Length" => post.size.to_s,
+          "SOAPAction" => "http://iveri.com/Execute"
+        }
+      end
+
+      def parse(body)
+        parsed = {}
+
+        vxml = Nokogiri::XML(body).remove_namespaces!.xpath("//Envelope/Body/ExecuteResponse/ExecuteResult").inner_text
+        doc = Nokogiri::XML(vxml)
+        doc.xpath("*").each do |node|
+          if (node.elements.empty?)
+            parsed[underscore(node.name)] = node.text
+          else
+            node.elements.each do |childnode|
+              parse_element(parsed, childnode)
+            end
+          end
+        end
+        parsed
+      end
+
+      def parse_element(parsed, node)
+        if !node.attributes.empty?
+          node.attributes.each do |a|
+            parsed[underscore(node.name)+ "_" + underscore(a[1].name)] = a[1].value
+          end
+        end
+
+        if !node.elements.empty?
+          node.elements.each {|e| parse_element(parsed, e) }
+        else
+          parsed[underscore(node.name)] = node.text
+        end
+      end
+
+      def success_from(response)
+        response['result_status'] == '0'
+      end
+
+      def message_from(response, succeeded)
+        if succeeded
+          "Succeeded"
+        else
+          response['result_description'] || response['result_acquirer_description']
+        end
+      end
+
+      def authorization_from(response)
+        "#{response['transaction_request_id']}|#{response['transaction_index']}|#{response['merchant_reference']}"
+      end
+
+      def split_auth(authorization)
+        request_id, transaction_index, merchant_reference = authorization.to_s.split('|')
+        [request_id, transaction_index, merchant_reference]
+      end
+
+      def error_code_from(response, succeeded)
+        unless succeeded
+          response['result_code']
+        end
+      end
+
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+    end
+  end
+end