activemerchant 1.45.0 → 1.126.0

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

@@ -0,0 +1,179 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class AxcessmsGateway < Gateway
+      self.test_url = 'https://test.ctpe.io/payment/ctpe'
+      self.live_url = 'https://ctpe.io/payment/ctpe'
+
+      self.supported_countries = %w(AD AT BE BG BR CA CH CY CZ DE DK EE ES FI FO FR GB
+                                    GI GR HR HU IE IL IM IS IT LI LT LU LV MC MT MX NL
+                                    NO PL PT RO RU SE SI SK TR US VA)
+
+      self.supported_cardtypes = %i[visa master american_express discover jcb maestro]
+
+      self.homepage_url = 'http://www.axcessms.com/'
+      self.display_name = 'Axcess MS'
+      self.money_format = :dollars
+      self.default_currency = 'GBP'
+
+      API_VERSION = '1.0'
+      PAYMENT_CODE_PREAUTHORIZATION = 'CC.PA'
+      PAYMENT_CODE_DEBIT = 'CC.DB'
+      PAYMENT_CODE_CAPTURE = 'CC.CP'
+      PAYMENT_CODE_REVERSAL = 'CC.RV'
+      PAYMENT_CODE_REFUND = 'CC.RF'
+      PAYMENT_CODE_REBILL = 'CC.RB'
+
+      def initialize(options = {})
+        requires!(options, :sender, :login, :password, :channel)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        payment_code = payment.respond_to?(:number) ? PAYMENT_CODE_DEBIT : PAYMENT_CODE_REBILL
+        commit(payment_code, money, payment, options)
+      end
+
+      def authorize(money, authorization, options = {})
+        commit(PAYMENT_CODE_PREAUTHORIZATION, money, authorization, options)
+      end
+
+      def capture(money, authorization, options = {})
+        commit(PAYMENT_CODE_CAPTURE, money, authorization, options)
+      end
+
+      def refund(money, authorization, options = {})
+        commit(PAYMENT_CODE_REFUND, money, authorization, options)
+      end
+
+      def void(authorization, options = {})
+        commit(PAYMENT_CODE_REVERSAL, nil, authorization, options)
+      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(r.authorization, options) }
+        end
+      end
+
+      private
+
+      def commit(paymentcode, money, payment, options)
+        options[:mode] ||= (test? ? 'INTEGRATOR_TEST' : 'LIVE')
+        request = build_request(paymentcode, money, payment, options)
+
+        headers = {
+          'Content-Type' => 'application/x-www-form-urlencoded;charset=UTF-8'
+        }
+
+        response = parse(ssl_post((test? ? test_url : live_url), "load=#{CGI.escape(request)}", headers))
+        success = (response[:result] == 'ACK')
+        message = "#{response[:reason]} - #{response[:return]}"
+        authorization = response[:unique_id]
+
+        Response.new(success, message, response,
+          authorization: authorization,
+          test: (response[:mode] != 'LIVE'))
+      end
+
+      def parse(body)
+        return {} if body.blank?
+
+        xml = REXML::Document.new(body)
+
+        response = {}
+        xml.root.elements.to_a.each do |node|
+          parse_element(response, node)
+        end
+
+        response[:mode] = REXML::XPath.first(xml, '//Transaction').attributes['mode']
+
+        response
+      end
+
+      def parse_element(response, node)
+        node.attributes.each { |name, value| response["#{node.name}_#{name}".underscore.to_sym] = value } if node.has_attributes?
+
+        if node.has_elements?
+          node.elements.each { |element| parse_element(response, element) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+
+      def build_request(payment_code, money, payment, options)
+        xml = Builder::XmlMarkup.new indent: 2
+        xml.instruct!
+        xml.tag! 'Request', 'version' => API_VERSION do
+          xml.tag! 'Header' do
+            xml.tag! 'Security', 'sender' => @options[:sender]
+          end
+          xml.tag! 'Transaction', 'mode' => options[:mode], 'channel' => @options[:channel], 'response' => 'SYNC' do
+            xml.tag! 'User', 'login' => @options[:login], 'pwd' => @options[:password]
+            xml.tag! 'Identification' do
+              xml.tag! 'TransactionID', options[:order_id] || generate_unique_id
+              xml.tag! 'ReferenceID', payment unless payment.respond_to?(:number)
+            end
+
+            xml.tag! 'Payment', 'code' => payment_code do
+              xml.tag! 'Memo', options[:memo] unless options[:memo].blank?
+              xml.tag! 'Presentation' do
+                xml.tag! 'Amount', amount(money)
+                xml.tag! 'Currency', (options[:currency] || currency(money))
+                xml.tag! 'Usage', options[:description]
+              end
+            end
+
+            if payment.respond_to?(:number)
+              add_payment(xml, payment)
+
+              xml.tag! 'Customer' do
+                add_customer_name(xml, payment)
+                add_address(xml, options[:billing_address] || options[:address])
+                add_contact(xml, options)
+              end
+            end
+          end
+        end
+
+        xml.target!
+      end
+
+      def add_contact(xml, options)
+        xml.tag! 'Contact' do
+          xml.tag! 'Email', (options[:email] || 'unknown@example.com')
+          xml.tag! 'Ip', (options[:ip] || '127.0.0.1')
+        end
+      end
+
+      def add_customer_name(xml, payment)
+        xml.tag! 'Name' do
+          xml.tag! 'Given', payment.first_name
+          xml.tag! 'Family', payment.last_name
+        end
+      end
+
+      def add_payment(xml, payment)
+        xml.tag! 'Account' do
+          xml.tag! 'Number', payment.number
+          xml.tag! 'Holder', payment.name
+          xml.tag! 'Brand', payment.brand
+          xml.tag! 'Expiry', 'month' => payment.month, 'year' => payment.year
+          xml.tag! 'Verification', payment.verification_value
+        end
+      end
+
+      def add_address(xml, address)
+        raise ArgumentError.new('Address is required') unless address
+
+        xml.tag! 'Address' do
+          xml.tag! 'Street', "#{address[:address1]} #{address[:address2]}".strip
+          xml.tag! 'City', address[:city]
+          xml.tag! 'State', address[:state]
+          xml.tag! 'Zip', address[:zip]
+          xml.tag! 'Country', address[:country]
+        end
+      end
+    end
+  end
+end

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

@@ -17,12 +17,12 @@ module ActiveMerchant #:nodoc:
     #    live" button on the Balanced dashboard and fill in your marketplace
     #    details.
     class BalancedGateway < Gateway
-      VERSION = "2.0.0"
+      VERSION = '2.0.0'
 
       self.live_url = 'https://api.balancedpayments.com'
 
       self.supported_countries = ['US']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
       self.homepage_url = 'https://www.balancedpayments.com/'
       self.display_name = 'Balanced'
       self.money_format = :cents
@@ -44,13 +44,14 @@ module ActiveMerchant #:nodoc:
         add_common_params(post, options)
 
         MultiResponse.run do |r|
-          identifier = if(payment_method.respond_to?(:number))
-            r.process{store(payment_method, options)}
-            r.authorization
-          else
-            payment_method
-          end
-          r.process{commit("debits", "cards/#{card_identifier_from(identifier)}/debits", post)}
+          identifier =
+            if payment_method.respond_to?(:number)
+              r.process { store(payment_method, options) }
+              r.authorization
+            else
+              payment_method
+            end
+          r.process { commit('debits', "cards/#{card_identifier_from(identifier)}/debits", post) }
         end
       end
 
@@ -61,13 +62,14 @@ module ActiveMerchant #:nodoc:
         add_common_params(post, options)
 
         MultiResponse.run do |r|
-          identifier = if(payment_method.respond_to?(:number))
-            r.process{store(payment_method, options)}
-            r.authorization
-          else
-            payment_method
-          end
-          r.process{commit("card_holds", "cards/#{card_identifier_from(identifier)}/card_holds", post)}
+          identifier =
+            if payment_method.respond_to?(:number)
+              r.process { store(payment_method, options) }
+              r.authorization
+            else
+              payment_method
+            end
+          r.process { commit('card_holds', "cards/#{card_identifier_from(identifier)}/card_holds", post) }
         end
       end
 
@@ -77,7 +79,7 @@ module ActiveMerchant #:nodoc:
         post[:description] = options[:description] if options[:description]
         add_common_params(post, options)
 
-        commit("debits", "card_holds/#{reference_identifier_from(identifier)}/debits", post)
+        commit('debits', "card_holds/#{reference_identifier_from(identifier)}/debits", post)
       end
 
       def void(identifier, options = {})
@@ -85,7 +87,7 @@ module ActiveMerchant #:nodoc:
         post[:is_void] = true
         add_common_params(post, options)
 
-        commit("card_holds", "card_holds/#{reference_identifier_from(identifier)}", post, :put)
+        commit('card_holds', "card_holds/#{reference_identifier_from(identifier)}", post, :put)
       end
 
       def refund(money, identifier, options = {})
@@ -94,10 +96,10 @@ module ActiveMerchant #:nodoc:
         post[:description] = options[:description]
         add_common_params(post, options)
 
-        commit("refunds", "debits/#{reference_identifier_from(identifier)}/refunds", post)
+        commit('refunds', "debits/#{reference_identifier_from(identifier)}/refunds", post)
       end
 
-      def store(credit_card, options={})
+      def store(credit_card, options = {})
         post = {}
 
         post[:number] = credit_card.number
@@ -108,7 +110,7 @@ module ActiveMerchant #:nodoc:
 
         add_address(post, options)
 
-        commit("cards", "cards", post)
+        commit('cards', 'cards', post)
       end
 
       private
@@ -117,18 +119,18 @@ module ActiveMerchant #:nodoc:
         case identifier
         when %r{\|}
           uri = identifier.
-            split("|").
-            detect{|part| part.size > 0}
-          uri.split("/")[2]
+                split('|').
+                detect { |part| part.size > 0 }
+          uri.split('/')[2]
         when %r{\/}
-          identifier.split("/")[5]
+          identifier.split('/')[5]
         else
           identifier
         end
       end
 
       def card_identifier_from(identifier)
-        identifier.split("/").last
+        identifier.split('/').last
       end
 
       def add_amount(post, money)
@@ -137,7 +139,7 @@ module ActiveMerchant #:nodoc:
 
       def add_address(post, options)
         address = (options[:billing_address] || options[:address])
-        if(address && address[:zip].present?)
+        if address && address[:zip].present?
           post[:address] = {}
           post[:address][:line1] = address[:address1] if address[:address1]
           post[:address][:line2] = address[:address2] if address[:address2]
@@ -154,55 +156,59 @@ module ActiveMerchant #:nodoc:
         post[:meta] = options[:meta]
       end
 
-      def commit(entity_name, path, post, method=:post)
-        raw_response = begin
-          parse(ssl_request(
-            method,
-            live_url + "/#{path}",
-            post_data(post),
-            headers
-          ))
-        rescue ResponseError => e
-          raise unless(e.response.code.to_s =~ /4\d\d/)
-          parse(e.response.body)
-        end
+      def commit(entity_name, path, post, method = :post)
+        raw_response =
+          begin
+            parse(
+              ssl_request(
+                method,
+                live_url + "/#{path}",
+                post_data(post),
+                headers
+              )
+            )
+          rescue ResponseError => e
+            raise unless e.response.code.to_s =~ /4\d\d/
+
+            parse(e.response.body)
+          end
 
         Response.new(
           success_from(entity_name, raw_response),
           message_from(raw_response),
           raw_response,
           authorization: authorization_from(entity_name, raw_response),
-          test: test?,
+          test: test?
         )
       end
 
       def success_from(entity_name, raw_response)
         entity = (raw_response[entity_name] || []).first
-        if(!entity)
+        if !entity
           false
-        elsif((entity_name == "refunds") && entity.include?("status"))
-          %w(succeeded pending).include?(entity["status"])
-        elsif(entity.include?("status"))
-          (entity["status"] == "succeeded")
-        elsif(entity_name == "cards")
-          !!entity["id"]
+        elsif (entity_name == 'refunds') && entity.include?('status')
+          %w(succeeded pending).include?(entity['status'])
+        elsif entity.include?('status')
+          (entity['status'] == 'succeeded')
+        elsif entity_name == 'cards'
+          !!entity['id']
         else
           false
         end
       end
 
       def message_from(raw_response)
-        if(raw_response["errors"])
-          error = raw_response["errors"].first
-          (error["additional"] || error["message"] || error["description"])
+        if raw_response['errors']
+          error = raw_response['errors'].first
+          (error['additional'] || error['message'] || error['description'])
         else
-          "Success"
+          'Success'
         end
       end
 
       def authorization_from(entity_name, raw_response)
         entity = (raw_response[entity_name] || []).first
-        (entity && entity["id"])
+        (entity && entity['id'])
       end
 
       def parse(body)
@@ -211,8 +217,8 @@ module ActiveMerchant #:nodoc:
         message = 'Invalid response received from the Balanced API. Please contact support@balancedpayments.com if you continue to receive this message.'
         message += " (The raw response returned by the API was #{raw_response.inspect})"
         {
-          "errors" => [{
-            "message" => message
+          'errors' => [{
+            'message' => message
           }]
         }
       end
@@ -222,6 +228,7 @@ module ActiveMerchant #:nodoc:
 
         params.map do |key, value|
           next if value.blank?
+
           if value.is_a?(Hash)
             h = {}
             value.each do |k, v|
@@ -231,24 +238,24 @@ module ActiveMerchant #:nodoc:
           else
             "#{key}=#{CGI.escape(value.to_s)}"
           end
-        end.compact.join("&")
+        end.compact.join('&')
       end
 
       def headers
         @@ua ||= JSON.dump(
-           bindings_version: ActiveMerchant::VERSION,
-           lang: 'ruby',
-           lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
-           lib_version: BalancedGateway::VERSION,
-           platform: RUBY_PLATFORM,
-           publisher: 'active_merchant'
+          bindings_version: ActiveMerchant::VERSION,
+          lang: 'ruby',
+          lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+          lib_version: BalancedGateway::VERSION,
+          platform: RUBY_PLATFORM,
+          publisher: 'active_merchant'
         )
 
         {
-            "Authorization" => "Basic " + Base64.encode64(@options[:login].to_s + ":").strip,
-            "User-Agent" => "Balanced/v1.1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
-            "Accept" => "application/vnd.api+json;revision=1.1",
-            "X-Balanced-User-Agent" => @@ua,
+          'Authorization' => 'Basic ' + Base64.encode64(@options[:login].to_s + ':').strip,
+          'User-Agent' => "Balanced/v1.1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'Accept' => 'application/vnd.api+json;revision=1.1',
+          'X-Balanced-User-Agent' => @@ua
         }
       end
     end

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

@@ -0,0 +1,222 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BamboraApacGateway < Gateway
+      self.live_url = 'https://www.bambora.co.nz/interface/api'
+      self.test_url = 'https://demo.bambora.co.nz/interface/api'
+
+      self.supported_countries = %w[AU NZ]
+      self.supported_cardtypes = %i[visa master american_express diners_club jcb]
+
+      self.homepage_url = 'http://www.bambora.com/'
+      self.display_name = 'Bambora Asia-Pacific'
+
+      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]
+            xml.Amount amount(money)
+            xml.TrnType '1'
+            add_payment(xml, payment)
+            add_credentials(xml, options)
+            xml.TrnSource options[:ip]
+          end
+        end
+      end
+
+      def authorize(money, payment, options = {})
+        commit('SubmitSinglePayment') do |xml|
+          xml.Transaction do
+            xml.CustRef options[:order_id]
+            xml.Amount amount(money)
+            xml.TrnType '2'
+            add_payment(xml, payment)
+            add_credentials(xml, options)
+            xml.TrnSource options[:ip]
+          end
+        end
+      end
+
+      def capture(money, authorization, options = {})
+        commit('SubmitSingleCapture') do |xml|
+          xml.Capture do
+            xml.Receipt authorization
+            xml.Amount amount(money)
+            add_credentials(xml, options)
+          end
+        end
+      end
+
+      def refund(money, authorization, options = {})
+        commit('SubmitSingleRefund') do |xml|
+          xml.Refund do
+            xml.Receipt authorization
+            xml.Amount amount(money)
+            add_credentials(xml, options)
+          end
+        end
+      end
+
+      def void(authorization, options = {})
+        commit('SubmitSingleVoid') do |xml|
+          xml.Void do
+            xml.Receipt authorization
+            xml.Amount amount(options[:amount])
+            add_credentials(xml, options)
+          end
+        end
+      end
+
+      def store(payment, options = {})
+        commit('TokeniseCreditCard') do |xml|
+          xml.TokeniseCreditCard do
+            xml.CardNumber payment.number
+            xml.ExpM format(payment.month, :two_digits)
+            xml.ExpY format(payment.year, :four_digits)
+            xml.TokeniseAlgorithmID options[:tokenise_algorithm_id] || 2
+            xml.UserName @options[:username]
+            xml.Password @options[:password]
+          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, options)
+        xml.AccountNumber options[:account_number] if options[:account_number]
+        xml.Security do
+          xml.UserName @options[:username]
+          xml.Password @options[:password]
+        end
+      end
+
+      def add_payment(xml, payment)
+        if payment.is_a?(String)
+          add_token(xml, payment)
+        else
+          add_credit_card(xml, payment)
+        end
+      end
+
+      def add_token(xml, payment)
+        xml.CreditCard do
+          xml.TokeniseAlgorithmID options[:tokenise_algorithm_id] || 2
+          xml.CardNumber payment
+        end
+      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/#{endpoint(action)}/#{action}"
+        }
+        response = parse(ssl_post("#{commit_url}/#{endpoint(action)}.asmx", 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/#{endpoint(action)}") do
+              if action == 'TokeniseCreditCard'
+                xml.tokeniseCreditCardXML do
+                  inner_xml = Builder::XmlMarkup.new(indent: 2)
+                  yield(inner_xml)
+                  xml.cdata!(inner_xml.target!)
+                end
+              else
+                xml.trnXML do
+                  inner_xml = Builder::XmlMarkup.new(indent: 2)
+                  yield(inner_xml)
+                  xml.cdata!(inner_xml.target!)
+                end
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def endpoint(action)
+        action == 'TokeniseCreditCard' ? 'sipp' : 'dts'
+      end
+
+      def commit_url
+        test? ? test_url : live_url
+      end
+
+      def success_from(response)
+        response[:response_code] == '0' || response[:return_value] == '0'
+      end
+
+      def error_code_from(response)
+        STANDARD_ERROR_CODE_MAPPING[response[:declined_code]]
+      end
+
+      def message_from(response)
+        success_from(response) ? 'Succeeded' : response[:declined_message]
+      end
+
+      def authorization_from(response)
+        response[:receipt] || response[:token]
+      end
+    end
+  end
+end