activemerchant 1.56.0 → 1.66.0

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

@@ -0,0 +1,311 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class GlobalCollectGateway < Gateway
+      self.display_name = "GlobalCollect"
+      self.homepage_url = "http://www.globalcollect.com/"
+
+      self.test_url = "https://api-sandbox.globalcollect.com/"
+      self.live_url = "https://api.globalcollect.com/"
+
+      self.supported_countries = %w(AD AE AT AU BD BE BG BN CA CH CY CZ DE DK
+      EE EG ES FI FR GB GI GR HK HU ID IE IL IM IN IS IT JO KW LB LI LK LT LU
+      LV MC MT MU MV MX MY NL NO NZ OM PH PL PT QA RO SA SE SG SI SK SM TR TT
+      UM US VA VN ZA)
+      self.default_currency = "USD"
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :api_key_id, :secret_api_key)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        MultiResponse.run do |r|
+          r.process { authorize(money, payment, options) }
+          r.process { capture(money, r.authorization, options) } unless capture_requested?(r)
+        end
+      end
+
+      def authorize(money, payment, options={})
+        post = nestable_hash
+        add_order(post, money, options)
+        add_payment(post, payment)
+        add_customer_data(post, options, payment)
+        add_address(post, payment, options)
+
+        commit(:authorize, post)
+      end
+
+      def capture(money, authorization, options={})
+        post = nestable_hash
+        add_order(post, money, options)
+        add_customer_data(post, options)
+        commit(:capture, post, authorization)
+      end
+
+      def refund(money, authorization, options={})
+        post = nestable_hash
+        add_amount(post, money, options)
+        add_refund_customer_data(post, options)
+        commit(:refund, post, authorization)
+      end
+
+      def void(authorization, options={})
+        post = nestable_hash
+        commit(:void, post, authorization)
+      end
+
+      def verify(payment, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, payment, options) }
+          r.process { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: )[^\\]*)i, '\1[FILTERED]').
+          gsub(%r(("cardNumber\\":\\")\d+), '\1[FILTERED]').
+          gsub(%r(("cvv\\":\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      BRAND_MAP = {
+        "visa" => "1",
+        "american_express" => "2",
+        "master" => "3",
+        "discover" => "128",
+        "jcb" => "125",
+        "diners_club" => "132"
+      }
+
+      def add_order(post, money, options)
+        post["order"]["amountOfMoney"] = {
+          "amount" => amount(money),
+          "currencyCode" => options[:currency] || currency(money)
+        }
+        post["order"]["references"] = {
+          "merchantReference" => options[:order_id],
+          "descriptor" => options[:description] # Max 256 chars
+        }
+        post["order"]["references"]["invoiceData"] = {
+          "invoiceNumber" => options[:invoice]
+        }
+      end
+
+      def add_amount(post, money, options={})
+        post["amountOfMoney"] = {
+          "amount" => amount(money),
+          "currencyCode" => options[:currency] || currency(money)
+        }
+      end
+
+      def add_payment(post, payment)
+        year  = format(payment.year, :two_digits)
+        month = format(payment.month, :two_digits)
+        expirydate =   "#{month}#{year}"
+
+        post["cardPaymentMethodSpecificInput"] = {
+            "paymentProductId" => BRAND_MAP[payment.brand],
+            "skipAuthentication" => "true", # refers to 3DSecure
+            "skipFraudService" => "true"
+        }
+        post["cardPaymentMethodSpecificInput"]["card"] = {
+            "cvv" => payment.verification_value,
+            "cardNumber" => payment.number,
+            "expiryDate" => expirydate,
+            "cardholderName" => payment.name
+        }
+      end
+
+      def add_customer_data(post, options, payment = nil)
+        post["order"]["customer"] = {
+          "merchantCustomerId" => options[:customer]
+        }
+        if payment
+          post["order"]["customer"]["personalInformation"] = {
+            "name" => {
+              "firstName" => payment.first_name[0..14],
+              "surname" => payment.last_name[0..69]
+            }
+          }
+        end
+        post["order"]["companyInformation"] = {
+          "name" => options[:company]
+        }
+        post["order"]["contactDetails"] = {
+          "emailAddress" => options[:email]
+        }
+        if address = options[:billing_address] || options[:address]
+          post["order"]["contactDetails"] = {
+            "phoneNumber" => address[:phone]
+          }
+        end
+      end
+
+      def add_refund_customer_data(post, options)
+        if address = options[:billing_address] || options[:address]
+          post["customer"]["address"] = {
+            "countryCode" => address[:country]
+          }
+          post["customer"]["contactDetails"] = {
+            "emailAddress" => options[:email],
+            "phoneNumber" => address[:phone]
+          }
+        end
+      end
+
+      def add_address(post, creditcard, options)
+        billing_address = options[:billing_address] || options[:address]
+        shipping_address = options[:shipping_address]
+        if billing_address = options[:billing_address] || options[:address]
+          post["order"]["customer"]["billingAddress"] = {
+            "street" => billing_address[:address1],
+            "additionalInfo" => billing_address[:address2],
+            "zip" => billing_address[:zip],
+            "city" => billing_address[:city],
+            "state" => billing_address[:state],
+            "countryCode" => billing_address[:country]
+          }
+        end
+        if shipping_address
+          post["order"]["customer"]["shippingAddress"] = {
+            "street" => shipping_address[:address1],
+            "additionalInfo" => shipping_address[:address2],
+            "zip" => shipping_address[:zip],
+            "city" => shipping_address[:city],
+            "state" => shipping_address[:state],
+            "countryCode" => shipping_address[:country]
+          }
+          post["order"]["customer"]["shippingAddress"]["name"] = {
+            "firstName" => shipping_address[:firstname],
+            "surname" => shipping_address[:lastname]
+          }
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def url(action, authorization)
+        (test? ? test_url : live_url) + uri(action, authorization)
+      end
+
+      def uri(action, authorization)
+        uri = "/v1/#{@options[:merchant_id]}/"
+        case action
+        when :authorize
+          uri + "payments"
+        when :capture
+          uri + "payments/#{authorization}/approve"
+        when :refund
+          uri + "payments/#{authorization}/refund"
+        when :void
+          uri + "payments/#{authorization}/cancel"
+        end
+      end
+
+      def commit(action, post, authorization = nil)
+        begin
+          response = parse(ssl_post(url(action, authorization), post.to_json, headers(action, post, authorization)))
+        rescue ResponseError => e
+          if e.response.code.to_i >= 400
+            response = parse(e.response.body)
+          end
+        end
+
+        succeeded = success_from(response)
+        Response.new(
+        succeeded,
+        message_from(succeeded, response),
+        response,
+        authorization: authorization_from(succeeded, response),
+        error_code: error_code_from(succeeded, response),
+        test: test?
+        )
+
+      end
+
+      def headers(action, post, authorization = nil)
+        {
+          "Content-type"  => content_type,
+          "Authorization" => auth_digest(action, post, authorization),
+          "Date" => date
+        }
+      end
+
+      def auth_digest(action, post, authorization = nil)
+        data = <<-EOS
+POST
+#{content_type}
+#{date}
+#{uri(action, authorization)}
+EOS
+        digest = OpenSSL::Digest.new('sha256')
+        key = @options[:secret_api_key]
+        "GCS v1HMAC:#{@options[:api_key_id]}:#{Base64.strict_encode64(OpenSSL::HMAC.digest(digest, key, data))}"
+      end
+
+      def date
+        @date ||= Time.now.strftime("%a, %d %b %Y %H:%M:%S %Z") # Must be same in digest and HTTP header
+      end
+
+      def content_type
+        "application/json"
+      end
+
+      def success_from(response)
+        !response["errorId"] && response["status"] != "REJECTED"
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          if errors = response["errors"]
+            errors.first.try(:[], "message")
+          elsif status = response["status"]
+            "Status: " + status
+          else
+            "No message available"
+          end
+        end
+      end
+
+      def authorization_from(succeeded, response)
+        if succeeded
+          response["id"] || response["payment"]["id"] || response["paymentResult"]["payment"]["id"]
+        else
+          response["errorId"]
+        end
+      end
+
+      def error_code_from(succeeded, response)
+        unless succeeded
+          if errors = response["errors"]
+            errors.first.try(:[], "code")
+          elsif status = response.try(:[], "statusOutput").try(:[], "statusCode")
+            status.to_s
+          else
+            "No error code available"
+          end
+        end
+      end
+
+      def nestable_hash
+        Hash.new {|h,k| h[k] = Hash.new(&h.default_proc) }
+      end
+
+      def capture_requested?(response)
+        response.params.try(:[], "payment").try(:[], "status") == "CAPTURE_REQUESTED"
+      end
+    end
+  end
+end

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

@@ -9,6 +9,7 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = %w(CA PR US)
       self.default_currency = 'USD'
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.ssl_version = :TLSv1
 
       self.homepage_url = 'https://www.globalpaymentsinc.com'
       self.display_name = 'Global Transport'

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

@@ -75,6 +75,19 @@ module ActiveMerchant #:nodoc:
         commit(:unstore, post)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<agentCode>).+(</agentCode>)), '\1[FILTERED]\2').
+          gsub(%r((<password>).+(</password>)), '\1[FILTERED]\2').
+          gsub(%r((<creditCardNum>).+(</creditCardNum>)), '\1[FILTERED]\2').
+          gsub(%r((<cvv2>).+(</cvv2>)), '\1[FILTERED]\2').
+          gsub(%r((<accountNum>).+(</accountNum>)), '\1[FILTERED]\2')
+      end
+
       private
 
       def add_ip(post, options)

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

@@ -0,0 +1,15 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class InContextPaypalExpressGateway < PaypalExpressGateway
+      self.test_redirect_url = 'https://www.sandbox.paypal.com/checkoutnow'
+      self.live_redirect_url = 'https://www.paypal.com/checkoutnow'
+
+      def redirect_url_for(token, options = {})
+        options = {review: true}.update(options)
+        url  = "#{redirect_url}?token=#{token}"
+        url += '&useraction=commit' unless options[:review]
+        url
+      end
+    end
+  end
+end

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