start_activemerchant 1.50.0

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

@@ -0,0 +1,140 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Bogus Gateway
+    class BogusGateway < Gateway
+      AUTHORIZATION = '53433'
+
+      SUCCESS_MESSAGE = "Bogus Gateway: Forced success"
+      FAILURE_MESSAGE = "Bogus Gateway: Forced failure"
+      ERROR_MESSAGE = "Bogus Gateway: Use CreditCard number ending in 1 for success, 2 for exception and anything else for error"
+      UNSTORE_ERROR_MESSAGE = "Bogus Gateway: Use trans_id ending in 1 for success, 2 for exception and anything else for error"
+      CAPTURE_ERROR_MESSAGE = "Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success"
+      VOID_ERROR_MESSAGE = "Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success"
+      REFUND_ERROR_MESSAGE = "Bogus Gateway: Use trans_id number ending in 1 for exception, 2 for error and anything else for success"
+      CHECK_ERROR_MESSAGE = "Bogus Gateway: Use bank account number ending in 1 for success, 2 for exception and anything else for error"
+
+      self.supported_countries = []
+      self.supported_cardtypes = [:bogus]
+      self.homepage_url = 'http://example.com'
+      self.display_name = 'Bogus'
+
+      def authorize(money, paysource, options = {})
+        money = amount(money)
+        case normalize(paysource)
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, {:authorized_amount => money}, :test => true, :authorization => AUTHORIZATION )
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:authorized_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+
+      def purchase(money, paysource, options = {})
+        money = amount(money)
+        case normalize(paysource)
+        when /1$/, AUTHORIZATION
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true, :authorization => AUTHORIZATION)
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+
+      def credit(money, paysource, options = {})
+        if paysource.is_a?(String)
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
+          return refund(money, paysource, options)
+        end
+
+        money = amount(money)
+        case normalize(paysource)
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true )
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+
+      def refund(money, reference, options = {})
+        money = amount(money)
+        case reference
+        when /1$/
+          raise Error, REFUND_ERROR_MESSAGE
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
+        end
+      end
+
+      def capture(money, reference, options = {})
+        money = amount(money)
+        case reference
+        when /1$/
+          raise Error, CAPTURE_ERROR_MESSAGE
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
+        end
+      end
+
+      def void(reference, options = {})
+        case reference
+        when /1$/
+          raise Error, VOID_ERROR_MESSAGE
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:authorization => reference, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          Response.new(true, SUCCESS_MESSAGE, {:authorization => reference}, :test => true)
+        end
+      end
+
+      def store(paysource, options = {})
+        case normalize(paysource)
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, {:billingid => '1'}, :test => true, :authorization => AUTHORIZATION)
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:billingid => nil, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+
+      def unstore(reference, options = {})
+        case reference
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, {}, :test => true)
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:error => FAILURE_MESSAGE },:test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, UNSTORE_ERROR_MESSAGE
+        end
+      end
+
+      private
+
+      def normalize(paysource)
+        if paysource.respond_to?(:account_number) && (paysource.try(:number).blank? || paysource.number.blank?)
+          paysource.account_number
+        elsif paysource.respond_to?(:number)
+          paysource.number
+        else
+          paysource.to_s
+        end
+      end
+
+      def error_message(paysource)
+        if paysource.respond_to?(:account_number)
+          CHECK_ERROR_MESSAGE
+        elsif paysource.respond_to?(:number)
+          ERROR_MESSAGE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BorgunGateway < Gateway
+      self.display_name = "Borgun"
+      self.homepage_url = 'http://www.borgun.com'
+
+      self.test_url = 'https://gatewaytest.borgun.is/ws/Heimir.pub.ws:Authorization'
+      self.live_url = 'https://gateway01.borgun.is/ws/Heimir.pub.ws:Authorization'
+
+      self.supported_countries = ['IS', 'GB', 'HU', 'CZ', 'DE', 'DK', 'SE' ]
+      self.default_currency = 'ISK'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb]
+
+      self.homepage_url = 'https://www.borgun.is/'
+
+      def initialize(options={})
+        requires!(options, :processor, :merchant_id, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = {}
+        post[:TransType] = '1'
+        add_invoice(post, money, options)
+        add_payment_method(post, payment)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        post[:TransType] = '5'
+        add_invoice(post, money, options)
+        add_payment_method(post, payment)
+
+        commit('authonly', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        post[:TransType] = '1'
+        add_invoice(post, money, options)
+        add_reference(post, authorization)
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        post[:TransType] = '3'
+        add_invoice(post, money, options)
+        add_reference(post, authorization)
+        commit('refund', post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        # TransType and TrAmount must match original values from auth or purchase.
+        _, _, _, _, _, transtype, tramount = split_authorization(authorization)
+        post[:TransType] = transtype
+        add_invoice(post, tramount.to_i, options)
+        add_reference(post, authorization)
+        commit('void', post)
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency for HDFC: #{k}")}
+      CURRENCY_CODES["ISK"] = "352"
+      CURRENCY_CODES["EUR"] = "978"
+
+      def add_invoice(post, money, options)
+        post[:TrAmount] = amount(money)
+        post[:TrCurrency] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:PAN] = payment_method.number
+        post[:ExpDate] = format(payment_method.year, :two_digits) + format(payment_method.month, :two_digits)
+        post[:CVC2] = payment_method.verification_value
+        post[:DateAndTime] = Time.now.strftime("%y%m%d%H%M%S")
+        post[:RRN] = 'AMRCNT' + six_random_digits
+      end
+
+      def add_reference(post, authorization)
+        dateandtime, batch, transaction, rrn, authcode, _, _ = split_authorization(authorization)
+        post[:DateAndTime] = dateandtime
+        post[:Batch] = batch
+        post[:Transaction] = transaction
+        post[:RRN] = rrn
+        post[:AuthCode] = authcode
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(CGI.unescapeHTML(xml))
+        body = doc.xpath('//getAuthorizationReply')
+        body = doc.xpath('//cancelAuthorizationReply') if body.length == 0
+        body.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 commit(action, post)
+        post[:Version] = '1000'
+        post[:Processor] = @options[:processor]
+        post[:MerchantID] = @options[:merchant_id]
+        post[:TerminalID] = 1
+
+        url = (test? ? test_url : live_url)
+        request = build_request(action, post)
+        raw = ssl_post(url(action), request, headers)
+        pairs = parse(raw)
+        success = success_from(pairs)
+
+        Response.new(
+          success,
+          message_from(success, pairs),
+          pairs,
+          authorization: authorization_from(pairs),
+          test: test?
+        )
+      end
+
+      def success_from(response)
+        (response[:actioncode] == '000')
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response[:message] || "Error with ActionCode=#{response[:actioncode]}"
+        end
+      end
+
+      def authorization_from(response)
+        [
+          response[:dateandtime],
+          response[:batch],
+          response[:transaction],
+          response[:rrn],
+          response[:authcode],
+          response[:transtype],
+          response[:tramount]
+        ].join("|")
+      end
+
+      def split_authorization(authorization)
+        dateandtime, batch, transaction, rrn, authcode, transtype, tramount = authorization.split("|")
+        [dateandtime, batch, transaction, rrn, authcode, transtype, tramount]
+      end
+
+      def headers
+        {
+          'Authorization' => 'Basic ' + Base64.strict_encode64(@options[:username].to_s + ':' + @options[:password].to_s),
+        }
+      end
+
+      def build_request(action, post)
+        mode = (action == 'void') ? 'cancel' : 'get'
+        xml = Builder::XmlMarkup.new :indent => 18
+        xml.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
+        xml.tag!("#{mode}Authorization") do
+          post.each do |field, value|
+            xml.tag!(field, value)
+          end
+        end
+        inner = CGI.escapeHTML(xml.target!)
+        envelope(mode).sub(/{{ :body }}/,inner)
+      end
+
+      def envelope(mode)
+        <<-EOS
+          <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:aut="http://Borgun/Heimir/pub/ws/Authorization">
+            <soapenv:Header/>
+            <soapenv:Body>
+              <aut:#{mode}AuthorizationInput>
+                <#{mode}AuthReqXml>
+                {{ :body }}
+                </#{mode}AuthReqXml>
+              </aut:#{mode}AuthorizationInput>
+            </soapenv:Body>
+          </soapenv:Envelope>
+        EOS
+      end
+
+      def url(action)
+        (test? ? test_url : live_url)
+      end
+
+      def six_random_digits
+        (0...6).map { (48 + rand(10)).chr }.join
+      end
+    end
+  end
+end

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

@@ -0,0 +1,277 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BpointGateway < Gateway
+      self.live_url = 'https://www.bpoint.com.au/evolve/service_1_4_4.asmx'
+
+      self.supported_countries = ['AU']
+      self.default_currency = 'AUD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+
+      self.homepage_url = 'https://www.bpoint.com.au/bpoint'
+      self.display_name = 'BPoint'
+
+      def initialize(options={})
+        requires!(options, :username, :password, :merchant_number)
+        super
+      end
+
+      def store(credit_card, options={})
+        options[:crn1] ||= 'DEFAULT'
+        request_body = soap_request do |xml|
+          add_token(xml, credit_card, options)
+        end
+        commit(request_body)
+      end
+
+      def purchase(amount, credit_card, options={})
+        request_body = soap_request do |xml|
+          process_payment(xml) do |payment_xml|
+            add_purchase(payment_xml, amount, credit_card, options)
+          end
+        end
+        commit(request_body)
+      end
+
+      def authorize(amount, credit_card, options={})
+        request_body = soap_request do |xml|
+          process_payment(xml) do |payment_xml|
+            add_authorize(payment_xml, amount, credit_card, options)
+          end
+        end
+        commit(request_body)
+      end
+
+      def capture(amount, authorization, options={})
+        request_body = soap_request do |xml|
+          process_payment(xml) do |payment_xml|
+            add_capture(payment_xml, amount, authorization, options)
+          end
+        end
+        commit(request_body)
+      end
+
+      def refund(amount, authorization, options={})
+        request_body = soap_request do |xml|
+          process_payment(xml) do |payment_xml|
+            add_refund(payment_xml, amount, authorization, options)
+          end
+        end
+        commit(request_body)
+      end
+
+      def void(amount, authorization, options={})
+        request_body = soap_request do |xml|
+          process_payment(xml) do |payment_xml|
+            add_void(payment_xml, amount, authorization, options)
+          end
+        end
+        commit(request_body)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(100, r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<password>).+(</password>)), '\1[FILTERED]\2').
+          gsub(%r((<CardNumber>).+(</CardNumber>)), '\1[FILTERED]\2').
+          gsub(%r((<CVC>).+(</CVC>)), '\1[FILTERED]\2')
+      end
+
+      private
+
+      def soap_request
+        Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |xml|
+          xml.send('soap12:Envelope', soap_envelope_attributes) {
+            xml.send('soap12:Body') {
+              yield(xml) if block_given?
+            }
+          }
+        end.to_xml
+      end
+
+      def soap_envelope_attributes
+        { 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+          'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+          'xmlns:soap12' => 'http://www.w3.org/2003/05/soap-envelope' }
+      end
+
+      def process_payment(xml)
+        xml.send('ProcessPayment', { 'xmlns' => 'urn:Eve_1_4_4' }) {
+          credentials_xml(xml)
+          xml.send('txnReq') {
+            yield(xml) if block_given?
+          }
+        }
+      end
+
+      def add_token(xml, credit_card, options)
+        xml.send('AddToken', { 'xmlns' => 'urn:Eve_1_4_4' }) {
+          credentials_xml(xml)
+          xml.send('tokenRequest') {
+            xml.send('CRN1', options[:crn1])
+            xml.send('CRN2', '')
+            xml.send('CRN3', '')
+            xml.send('CardNumber', credit_card.number)
+            xml.send('ExpiryDate', expdate(credit_card))
+          }
+        }
+      end
+
+      def credentials_xml(xml)
+        xml.send('username', @options[:username])
+        xml.send('password', @options[:password])
+        xml.send('merchantNumber', @options[:merchant_number])
+      end
+
+      def add_purchase(xml, amount, credit_card, options)
+        payment_xml(xml, 'PAYMENT', amount, options)
+        credit_card_xml(xml, credit_card)
+      end
+
+      def add_authorize(xml, amount, credit_card, options)
+        payment_xml(xml, 'PREAUTH', amount, options)
+        credit_card_xml(xml, credit_card)
+      end
+
+      def add_capture(xml, amount, transaction_number, options)
+        payment_xml(xml, 'CAPTURE', amount, options)
+        transaction_number_xml(xml, transaction_number)
+      end
+
+      def add_refund(xml, amount, transaction_number, options)
+        payment_xml(xml, 'REFUND', amount, options)
+        transaction_number_xml(xml, transaction_number)
+      end
+
+      def add_void(xml, amount, transaction_number, options)
+        payment_xml(xml, 'REVERSAL', amount, options)
+        transaction_number_xml(xml, transaction_number)
+      end
+
+      def payment_xml(xml, payment_type, amount, options)
+        xml.send('PaymentType', payment_type)
+        xml.send('TxnType', 'WEB_SHOP')
+        xml.send('BillerCode', options.fetch(:biller_code, ''))
+        xml.send('MerchantReference', '')
+        xml.send('CRN1', '')
+        xml.send('CRN2', '')
+        xml.send('CRN3', '')
+        xml.send('Amount', amount)
+      end
+
+      def credit_card_xml(xml, credit_card)
+        xml.send('CardNumber', credit_card.number)
+        xml.send('ExpiryDate', expdate(credit_card))
+        xml.send('CVC', credit_card.verification_value)
+      end
+
+      def transaction_number_xml(xml, transaction_number)
+        xml.send('OriginalTransactionNumber', transaction_number)
+      end
+
+      def commit(request_body)
+        parse(ssl_post(live_url, request_body, request_headers))
+      end
+
+      def request_headers
+        { "Content-Type" => "application/soap+xml; charset=utf-8" }
+      end
+
+      def parse(body)
+        response_for(Nokogiri::XML(body).remove_namespaces!)
+      end
+
+      def response_for(xml_doc)
+        if xml_doc.xpath('//ProcessPaymentResponse').any?
+          ProcessPaymentResponse.new(xml_doc, self).to_response
+        elsif xml_doc.xpath('//AddTokenResponse').any?
+          AddTokenResponse.new(xml_doc, self).to_response
+        end
+      end
+
+      class BPointResponse
+        attr_reader :xml_doc, :gateway, :params
+
+        def initialize(xml_doc, gateway)
+          @xml_doc = xml_doc
+          @gateway = gateway
+          @params = init_params
+        end
+
+        def to_response
+          Response.new(success?, message, params, options)
+        end
+
+        private
+
+        def init_params
+          {}.tap do |h|
+            xml_doc.xpath(response_node).each do |node|
+              if node.elements.empty?
+                h[node.name.to_sym] = node.text
+              else
+                node.elements.each do |childnode|
+                  name = "#{node.name}_#{childnode.name}"
+                  h[name.to_sym] = childnode.text
+                end
+              end
+            end
+          end
+        end
+
+        def response_node
+          "//#{self.class.name.split('::').last}/*"
+        end
+
+        def options
+          { authorization: params[authorization_key], test: gateway.test? }
+        end
+      end
+
+      class ProcessPaymentResponse < BPointResponse
+
+        private
+
+        def authorization_key
+          :ProcessPaymentResult_TransactionNumber
+        end
+
+        def success?
+          params[:ProcessPaymentResult_ResponseCode] == '0'
+        end
+
+        def message
+          params[:ProcessPaymentResult_AuthorisationResult]
+        end
+      end
+
+      class AddTokenResponse < BPointResponse
+
+        private
+
+        def authorization_key
+          :AddTokenResult_Token
+        end
+
+        def success?
+          params[:response_ResponseCode] == 'SUCCESS'
+        end
+
+        def message
+          params[:response_ResponseCode].capitalize
+        end
+      end
+    end
+  end
+end