archetype2142_activemerchant 1.124.0

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

@@ -0,0 +1,219 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class ExactGateway < Gateway
+      self.live_url = self.test_url = 'https://secure2.e-xact.com/vplug-in/transaction/rpc-enc/service.asmx'
+
+      API_VERSION = '8.5'
+
+      TEST_LOGINS = [{ login: 'A00049-01', password: 'test1' },
+                     { login: 'A00427-01', password: 'testus' }]
+
+      TRANSACTIONS = { sale: '00',
+                       authorization: '01',
+                       capture: '32',
+                       credit: '34' }
+
+      ENVELOPE_NAMESPACES = { 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+                              'xmlns:env' => 'http://schemas.xmlsoap.org/soap/envelope/',
+                              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance' }
+
+      SEND_AND_COMMIT_ATTRIBUTES = { 'xmlns:n1' => 'http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/Request',
+                                     'env:encodingStyle' => 'http://schemas.xmlsoap.org/soap/encoding/' }
+
+      SEND_AND_COMMIT_SOURCE_ATTRIBUTES = { 'xmlns:n2' => 'http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/encodedTypes',
+                                            'xsi:type' => 'n2:Transaction' }
+
+      POST_HEADERS = { 'soapAction' => 'http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/SendAndCommit',
+                       'Content-Type' => 'text/xml' }
+
+      SUCCESS = 'true'
+
+      SENSITIVE_FIELDS = %i[verification_str2 expiry_date card_number]
+
+      self.supported_countries = %w[CA US]
+      self.supported_cardtypes = %i[visa master american_express jcb discover]
+      self.homepage_url = 'http://www.e-xact.com'
+      self.display_name = 'E-xact'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+
+        super
+      end
+
+      def authorize(money, credit_card, options = {})
+        commit(:authorization, build_sale_or_authorization_request(money, credit_card, options))
+      end
+
+      def purchase(money, credit_card, options = {})
+        commit(:sale, build_sale_or_authorization_request(money, credit_card, options))
+      end
+
+      def capture(money, authorization, options = {})
+        commit(:capture, build_capture_or_credit_request(money, authorization, options))
+      end
+
+      def credit(money, authorization, options = {})
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, authorization, options)
+      end
+
+      def refund(money, authorization, options = {})
+        commit(:credit, build_capture_or_credit_request(money, authorization, options))
+      end
+
+      private
+
+      def build_request(action, body)
+        xml = Builder::XmlMarkup.new
+
+        xml.instruct!
+        xml.tag! 'env:Envelope', ENVELOPE_NAMESPACES do
+          xml.tag! 'env:Body' do
+            xml.tag! 'n1:SendAndCommit', SEND_AND_COMMIT_ATTRIBUTES do
+              xml.tag! 'SendAndCommitSource', SEND_AND_COMMIT_SOURCE_ATTRIBUTES do
+                add_credentials(xml)
+                add_transaction_type(xml, action)
+                xml << body
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def build_sale_or_authorization_request(money, credit_card, options)
+        xml = Builder::XmlMarkup.new
+
+        add_amount(xml, money)
+        add_credit_card(xml, credit_card)
+        add_customer_data(xml, options)
+        add_invoice(xml, options)
+
+        xml.target!
+      end
+
+      def build_capture_or_credit_request(money, identification, options)
+        xml = Builder::XmlMarkup.new
+
+        add_identification(xml, identification)
+        add_amount(xml, money)
+        add_customer_data(xml, options)
+
+        xml.target!
+      end
+
+      def add_credentials(xml)
+        xml.tag! 'ExactID', @options[:login]
+        xml.tag! 'Password', @options[:password]
+      end
+
+      def add_transaction_type(xml, action)
+        xml.tag! 'Transaction_Type', TRANSACTIONS[action]
+      end
+
+      def add_identification(xml, identification)
+        authorization_num, transaction_tag = identification.split(';')
+
+        xml.tag! 'Authorization_Num', authorization_num
+        xml.tag! 'Transaction_Tag', transaction_tag
+      end
+
+      def add_amount(xml, money)
+        xml.tag! 'DollarAmount', amount(money)
+      end
+
+      def add_credit_card(xml, credit_card)
+        xml.tag! 'Card_Number', credit_card.number
+        xml.tag! 'Expiry_Date', expdate(credit_card)
+        xml.tag! 'CardHoldersName', credit_card.name
+
+        if credit_card.verification_value?
+          xml.tag! 'CVD_Presence_Ind', '1'
+          xml.tag! 'VerificationStr2', credit_card.verification_value
+        end
+      end
+
+      def add_customer_data(xml, options)
+        xml.tag! 'Customer_Ref', options[:customer]
+        xml.tag! 'Client_IP', options[:ip]
+        xml.tag! 'Client_Email', options[:email]
+      end
+
+      def add_address(xml, options)
+        if address = options[:billing_address] || options[:address]
+          xml.tag! 'ZipCode', address[:zip]
+        end
+      end
+
+      def add_invoice(xml, options)
+        xml.tag! 'Reference_No', options[:order_id]
+        xml.tag! 'Reference_3',  options[:description]
+      end
+
+      def expdate(credit_card)
+        "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
+      end
+
+      def commit(action, request)
+        response = parse(ssl_post(self.live_url, build_request(action, request), POST_HEADERS))
+
+        Response.new(successful?(response), message_from(response), response,
+          test: test?,
+          authorization: authorization_from(response),
+          avs_result: { code: response[:avs] },
+          cvv_result: response[:cvv2])
+      rescue ResponseError => e
+        case e.response.code
+        when '401'
+          return Response.new(false, "Invalid Login: #{e.response.body}", {}, test: test?)
+        else
+          raise
+        end
+      end
+
+      def successful?(response)
+        response[:transaction_approved] == SUCCESS
+      end
+
+      def authorization_from(response)
+        if response[:authorization_num] && response[:transaction_tag]
+          "#{response[:authorization_num]};#{response[:transaction_tag]}"
+        else
+          ''
+        end
+      end
+
+      def message_from(response)
+        if response[:faultcode] && response[:faultstring]
+          response[:faultstring]
+        elsif response[:error_number] != '0'
+          response[:error_description]
+        else
+          result = response[:exact_message] || ''
+          result << " - #{response[:bank_message]}" unless response[:bank_message].blank?
+          result
+        end
+      end
+
+      def parse(xml)
+        response = {}
+        xml = REXML::Document.new(xml)
+
+        if root = REXML::XPath.first(xml, '//types:TransactionResult')
+          parse_elements(response, root)
+        elsif root = REXML::XPath.first(xml, '//soap:Fault')
+          parse_elements(response, root)
+        end
+
+        response.delete_if { |k, _v| SENSITIVE_FIELDS.include?(k) }
+      end
+
+      def parse_elements(response, root)
+        root.elements.to_a.each do |node|
+          response[node.name.gsub(/EXact/, 'Exact').underscore.to_sym] = (node.text || '').strip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+module ActiveMerchant
+  module Billing
+    class EzicGateway < Gateway
+      self.live_url = 'https://secure-dm3.ezic.com/gw/sas/direct3.2'
+
+      self.supported_countries = %w(AU CA CN FR DE GI IL MT MU MX NL NZ PA PH RU SG KR ES KN GB US)
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover jcb diners_club]
+
+      self.homepage_url = 'http://www.ezic.com/'
+      self.display_name = 'Ezic'
+
+      def initialize(options = {})
+        requires!(options, :account_id)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+
+        add_account_id(post)
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_customer_data(post, options)
+
+        commit('S', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+
+        add_account_id(post)
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_customer_data(post, options)
+
+        commit('A', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+
+        add_account_id(post)
+        add_invoice(post, money, options)
+        add_authorization(post, authorization)
+        add_pay_type(post)
+
+        commit('D', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+
+        add_account_id(post)
+        add_invoice(post, money, options)
+        add_authorization(post, authorization)
+        add_pay_type(post)
+
+        commit('R', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+
+        add_account_id(post)
+        add_authorization(post, authorization)
+        add_pay_type(post)
+
+        commit('U', post)
+      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
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((card_number=)\w+), '\1[FILTERED]').
+          gsub(%r((card_cvv2=)\w+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_account_id(post)
+        post[:account_id] = @options[:account_id]
+      end
+
+      def add_addresses(post, options)
+        add_billing_address(post, options)
+        add_shipping_address(post, options)
+      end
+
+      def add_billing_address(post, options)
+        address = options[:billing_address] || {}
+
+        post[:bill_name1], post[:bill_name2] = split_names(address[:name])
+        post[:bill_street] = address[:address1] if address[:address1]
+        post[:bill_city] = address[:city] if address[:city]
+        post[:bill_state] = address[:state] if address[:state]
+        post[:bill_zip] = address[:zip] if address[:zip]
+        post[:bill_country] = address[:country] if address[:country]
+        post[:cust_phone] = address[:phone] if address[:phone]
+      end
+
+      def add_shipping_address(post, options)
+        address = options[:shipping_address] || {}
+
+        post[:ship_name1], post[:ship_name2] = split_names(address[:name])
+        post[:ship_street] = address[:address1] if address[:address1]
+        post[:ship_city] = address[:city] if address[:city]
+        post[:ship_state] = address[:state] if address[:state]
+        post[:ship_zip] = address[:zip] if address[:zip]
+        post[:ship_country] = address[:country] if address[:country]
+      end
+
+      def add_customer_data(post, options)
+        post[:cust_ip] = options[:ip] if options[:ip]
+        post[:cust_email] = options[:email] if options[:email]
+        add_addresses(post, options)
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:description] = options[:description] if options[:description]
+      end
+
+      def add_payment(post, payment)
+        add_pay_type(post)
+        post[:card_number] = payment.number
+        post[:card_cvv2] = payment.verification_value
+        post[:card_expire] = expdate(payment)
+      end
+
+      def add_authorization(post, authorization)
+        post[:orig_id] = authorization
+      end
+
+      def add_pay_type(post)
+        post[:pay_type] = 'C'
+      end
+
+      def parse(body)
+        CGI::parse(body).inject({}) { |hash, (key, value)| hash[key] = value.first; hash }
+      end
+
+      def commit(transaction_type, parameters)
+        parameters[:tran_type] = transaction_type
+
+        begin
+          response = parse(ssl_post(live_url, post_data(parameters), headers))
+          Response.new(
+            success_from(response),
+            message_from(response),
+            response,
+            authorization: authorization_from(response),
+            avs_result: AVSResult.new(code: response['avs_code']),
+            cvv_result: CVVResult.new(response['cvv2_code']),
+            test: test?
+          )
+        rescue ResponseError => e
+          Response.new(false, e.response.message)
+        end
+      end
+
+      def success_from(response)
+        response['status_code'] == '1' || response['status_code'] == 'T'
+      end
+
+      def message_from(response)
+        response['auth_msg']
+      end
+
+      def authorization_from(response)
+        response['trans_id']
+      end
+
+      def post_data(parameters = {})
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+
+      def headers
+        {
+          'User-Agent' => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,223 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FatZebraGateway < Gateway
+      self.live_url = 'https://gateway.fatzebra.com.au/v1.0'
+      self.test_url = 'https://gateway.sandbox.fatzebra.com.au/v1.0'
+
+      self.supported_countries = ['AU']
+      self.default_currency = 'AUD'
+      self.money_format = :cents
+      self.supported_cardtypes = %i[visa master american_express jcb]
+
+      self.homepage_url = 'https://www.fatzebra.com.au/'
+      self.display_name = 'Fat Zebra'
+
+      def initialize(options = {})
+        requires!(options, :username, :token)
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        add_extra_options(post, options)
+        add_order_id(post, options)
+        add_ip(post, options)
+        add_metadata(post, options)
+
+        commit(:post, 'purchases', post)
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        add_extra_options(post, options)
+        add_order_id(post, options)
+        add_ip(post, options)
+        add_metadata(post, options)
+
+        post[:capture] = false
+
+        commit(:post, 'purchases', post)
+      end
+
+      def capture(money, authorization, options = {})
+        txn_id, = authorization.to_s.split('|')
+        post = {}
+
+        add_amount(post, money, options)
+        add_extra_options(post, options)
+
+        commit(:post, "purchases/#{CGI.escape(txn_id)}/capture", post)
+      end
+
+      def refund(money, authorization, options = {})
+        txn_id, = authorization.to_s.split('|')
+        post = {}
+
+        add_extra_options(post, options)
+        add_amount(post, money, options)
+        post[:transaction_id] = txn_id
+        add_order_id(post, options)
+
+        commit(:post, 'refunds', post)
+      end
+
+      def void(authorization, options = {})
+        txn_id, endpoint = authorization.to_s.split('|')
+
+        commit(:post, "#{endpoint}/void?id=#{txn_id}", {})
+      end
+
+      def store(creditcard, options = {})
+        post = {}
+
+        add_creditcard(post, creditcard)
+        post[:is_billing] = true if options[:recurring]
+
+        commit(:post, 'credit_cards', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r(("card_number\\?":\\?")[^"\\]*)i, '\1[FILTERED]').
+          gsub(%r(("cvv\\?":\\?")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_amount(post, money, options)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:currency] = post[:currency].upcase if post[:currency]
+        post[:amount] = money
+      end
+
+      def add_creditcard(post, creditcard, options = {})
+        if creditcard.respond_to?(:number)
+          post[:card_number] = creditcard.number
+          post[:card_expiry] = "#{creditcard.month}/#{creditcard.year}"
+          post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+          post[:card_holder] = creditcard.name if creditcard.name
+        elsif creditcard.is_a?(String)
+          id, = creditcard.to_s.split('|')
+          post[:card_token] = id
+          post[:cvv] = options[:cvv]
+        elsif creditcard.is_a?(Hash)
+          ActiveMerchant.deprecated 'Passing the credit card as a Hash is deprecated. Use a String and put the (optional) CVV in the options hash instead.'
+          post[:card_token] = creditcard[:token]
+          post[:cvv] = creditcard[:cvv]
+        else
+          raise ArgumentError.new("Unknown credit card format #{creditcard.inspect}")
+        end
+      end
+
+      def add_extra_options(post, options)
+        extra = {}
+        extra[:ecm] = '32' if options[:recurring]
+        extra[:cavv] = options[:cavv] || options.dig(:three_d_secure, :cavv) if options[:cavv] || options.dig(:three_d_secure, :cavv)
+        extra[:xid] = options[:xid] || options.dig(:three_d_secure, :xid) if options[:xid] || options.dig(:three_d_secure, :xid)
+        extra[:sli] = options[:sli] || options.dig(:three_d_secure, :eci) if options[:sli] || options.dig(:three_d_secure, :eci)
+        extra[:name] = options[:merchant] if options[:merchant]
+        extra[:location] = options[:merchant_location] if options[:merchant_location]
+        extra[:card_on_file] = options.dig(:extra, :card_on_file) if options.dig(:extra, :card_on_file)
+        extra[:auth_reason]  = options.dig(:extra, :auth_reason) if options.dig(:extra, :auth_reason)
+        post[:extra] = extra if extra.any?
+      end
+
+      def add_order_id(post, options)
+        post[:reference] = options[:order_id] || SecureRandom.hex(15)
+      end
+
+      def add_ip(post, options)
+        post[:customer_ip] = options[:ip] || '127.0.0.1'
+      end
+
+      def add_metadata(post, options)
+        post[:metadata] = options.fetch(:metadata, {})
+      end
+
+      def commit(method, uri, parameters = nil)
+        response =
+          begin
+            parse(ssl_request(method, get_url(uri), parameters.to_json, headers))
+          rescue ResponseError => e
+            return Response.new(false, 'Invalid Login') if e.response.code == '401'
+
+            parse(e.response.body)
+          end
+
+        success = success_from(response)
+        Response.new(
+          success,
+          message_from(response),
+          response,
+          test: response['test'],
+          authorization: authorization_from(response, success, uri)
+        )
+      end
+
+      def success_from(response)
+        (
+          response['successful'] &&
+          response['response'] &&
+          (response['response']['successful'] || response['response']['token'] || response['response']['response_code'] == '00')
+        )
+      end
+
+      def authorization_from(response, success, uri)
+        endpoint = uri.split('/')[0]
+        if success
+          id = response['response']['id'] || response['response']['token']
+          "#{id}|#{endpoint}"
+        else
+          nil
+        end
+      end
+
+      def message_from(response)
+        if !response['errors'].empty?
+          response['errors'].join(', ')
+        elsif response['response']['message']
+          response['response']['message']
+        else
+          'Unknown Error'
+        end
+      end
+
+      def parse(response)
+        JSON.parse(response)
+      rescue JSON::ParserError
+        msg = 'Invalid JSON response received from Fat Zebra. Please contact support@fatzebra.com.au if you continue to receive this message.'
+        msg += "  (The raw response returned by the API was #{response.inspect})"
+        {
+          'successful' => false,
+          'response' => {},
+          'errors' => [msg]
+        }
+      end
+
+      def get_url(uri)
+        base = test? ? self.test_url : self.live_url
+        base + '/' + uri
+      end
+
+      def headers
+        {
+          'Authorization' => 'Basic ' + Base64.strict_encode64(@options[:username].to_s + ':' + @options[:token].to_s).strip,
+          'User-Agent' => "Fat Zebra v1.0/ActiveMerchant #{ActiveMerchant::VERSION}"
+        }
+      end
+    end
+  end
+end