activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,225 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # For more information visit {Bank Frick Acquiring Services}[http://www.bankfrickacquiring.com/merchantsolutions_en.html]
+    #
+    # Written by Piers Chambers (Varyonic.com)
+    class BankFrickGateway < Gateway
+      self.test_url = 'https://test.ctpe.io/payment/ctpe'
+      self.live_url = 'https://ctpe.io/payment/ctpe'
+
+      self.supported_countries = ['LI', 'US']
+      self.default_currency = 'EUR'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.bankfrickacquiring.com/'
+      self.display_name = 'Bank Frick'
+
+      # The set of supported transactions for this gateway.
+      # More operations are supported by the gateway itself, but
+      # are not supported in this library.
+      SUPPORTED_TRANSACTIONS = {
+        'sale'      => 'CC.DB',
+        'authonly'  => 'CC.PA',
+        'capture'   => 'CC.CP',
+        'refund'    => 'CC.RF',
+        'void'      => 'CC.RV',
+      }
+
+      def initialize(options={})
+        requires!(options, :sender, :channel, :userid, :userpwd)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('authonly', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        post[:authorization] = authorization
+        add_invoice(post, money, options)
+
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        post[:authorization] = authorization
+        add_invoice(post, money, options)
+
+        commit('refund', post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        post[:authorization] = authorization
+
+        commit('void', 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
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] || 'noone@example.com'
+        post[:ip] = options[:ip] || '0.0.0.0'
+      end
+
+      def add_address(post, creditcard, options)
+        if address = options[:billing_address] || options[:address]
+          post[:address] = address[:address1].to_s
+          post[:company] = address[:company].to_s
+          post[:phone]   = address[:phone].to_s.gsub(/[^0-9]/, '') || '0000000'
+          post[:zip]     = address[:zip].to_s
+          post[:city]    = address[:city].to_s
+          post[:country] = address[:country].to_s
+          post[:state]   = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+      end
+
+      def add_invoice(post, money, options)
+        post[:order_id]    = options[:order_id] if post.has_key? :order_id
+        post[:amount]      = amount(money)
+        post[:currency]    = (options[:currency] || currency(money))
+        post[:description] = options[:description]
+      end
+
+      def add_payment(post, payment)
+        post[:first_name] = payment.first_name
+        post[:last_name]  = payment.last_name
+        post[:brand]      = payment.brand
+        post[:card_num]   = payment.number
+        post[:card_code]  = payment.verification_value if payment.verification_value?
+        post[:exp_year]   = payment.year
+        post[:exp_month]  = payment.month
+      end
+
+      def parse(body)
+        results  = {}
+        xml = Nokogiri::XML(body)
+        resp = xml.xpath('//Response/Transaction/Identification')
+        resp.children.each do |element|
+          results[element.name.downcase.to_sym] = element.text
+        end
+        resp = xml.xpath('//Response/Transaction/Processing')
+        resp.children.each do |element|
+          results[element.name.downcase.to_sym] = element.text
+        end
+        results
+      end
+
+      def commit(action, parameters)
+        url = (test? ? test_url : live_url)
+        headers = {
+          'Content-Type' => 'application/x-www-form-urlencoded;charset=UTF-8'
+        }
+        response = parse(ssl_post(url, post_data(action, parameters), headers))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?
+        )
+      end
+
+      def success_from(response)
+        response[:result] == 'ACK'
+      end
+
+      def message_from(response)
+        response[:return]
+      end
+
+      def authorization_from(response)
+        response[:uniqueid]
+      end
+
+      def post_data(action, parameters = {})
+        xml = build_xml_request(action, parameters)
+        "load=#{CGI.escape(xml)}"
+      end
+
+      def build_xml_request(action, data)
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.Request(version: '1.0') do
+          xml.Header do
+            xml.Security(sender: @options[:sender], type: 'MERCHANT')
+          end
+          xml.Transaction(response: 'SYNC', channel: @options[:channel], mode: 'LIVE') do
+            xml.User(pwd: @options[:userpwd], login: @options[:userid])
+            xml.Identification do
+              xml.TransactionID data[:order_id] if data.has_key? :order_id
+              xml.ReferenceID   data[:authorization] if data.has_key? :authorization
+            end
+            xml.Account do
+              xml.Holder        "#{data[:first_name]} #{data[:last_name]}"
+              xml.Brand         data[:brand]
+              xml.Number        data[:card_num]
+              xml.Bank          data[:bankname]
+              xml.Country       data[:country]
+              xml.Authorization data[:authorization]
+              xml.Verification  data[:card_code]
+              xml.Year          data[:exp_year]
+              xml.Month         data[:exp_month]
+            end if data.has_key? :card_num
+            xml.Payment(code: SUPPORTED_TRANSACTIONS[action]) do
+              xml.Presentation do
+                xml.Amount     data[:amount]
+                xml.Currency   data[:currency]
+                xml.Usage      data[:description]
+              end
+            end
+            xml.Customer do
+              xml.Contact do
+                xml.Email      data[:email]
+                xml.Mobile     data[:mobile]
+                xml.Ip         data[:ip]
+                xml.Phone      data[:phone]
+              end
+              xml.Address do
+                xml.Street     data[:address]
+                xml.Zip        data[:zip]
+                xml.City       data[:city]
+                xml.State      data[:state]
+                xml.Country    data[:country]
+              end
+              xml.Name do
+                xml.Salutation data[:salutation]
+                xml.Title      data[:title]
+                xml.Given      data[:first_name]
+                xml.Family     data[:last_name]
+                xml.Company    data[:company]
+              end
+            end if data.has_key? :last_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,20 +26,31 @@ module ActiveMerchant #:nodoc:
         commit(money, post)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((&?card_num=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?card_ccv2=)[^&]*)i, '\1[FILTERED]')
+      end
+
       private
 
       def add_response_type(post)
-        post[:response_format] = "JSON"
+        post[:response_format] = 'JSON'
       end
 
       def add_customer_data(post, options)
         post[:user] = @options[:login]
         post[:phone] = options[:billing_address][:phone]
-        post[:mail] = options[:email]
+        post[:mail] = options[:email] || 'unspecified@email.com'
       end
 
       def add_order_data(post, options)
-        post[:reference] = options[:order_id]
+        post[:reference] = options[:order_id] || generate_unique_id
         post[:concept] = options[:description]
       end
 
@@ -52,7 +63,7 @@ module ActiveMerchant #:nodoc:
         post[:card_num] = creditcard.number
         post[:card_name] = creditcard.name
         post[:card_type] = card_brand(creditcard)
-        post[:card_exp] = "#{sprintf("%02d", creditcard.month)}/#{"#{creditcard.year}"[-2, 2]}"
+        post[:card_exp] = "#{sprintf("%02d", creditcard.month)}/#{creditcard.year.to_s[-2, 2]}"
         post[:card_ccv2] = creditcard.verification_value
       end
 
@@ -63,7 +74,7 @@ module ActiveMerchant #:nodoc:
 
       def card_brand(card)
         brand = super
-        ({"master" => "mastercard", "american_express" => "amex"}[brand] || brand)
+        ({'master' => 'mastercard', 'american_express' => 'amex'}[brand] || brand)
       end
 
       def parse(body)
@@ -79,25 +90,25 @@ module ActiveMerchant #:nodoc:
         end
 
         Response.new(success?(response),
-                     response["message"],
-                     response,
-                     :test => test?,
-                     :authorization => response["code_auth"])
+          response['message'],
+          response,
+          :test => test?,
+          :authorization => response['code_auth'])
       end
 
       def success?(response)
-        (response["response"] == "ok")
+        (response['response'] == 'ok')
       end
 
       def post_data(parameters = {})
-        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def json_error(raw_response)
         msg = 'Invalid response received from the Banwire API.  Please contact Banwire support if you continue to receive this message.'
         msg += "  (The raw response returned by the API was #{raw_response.inspect})"
         {
-          "message" => msg
+          'message' => msg
         }
       end
     end

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

@@ -0,0 +1,351 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BarclaycardSmartpayGateway < Gateway
+      self.test_url = 'https://pal-test.barclaycardsmartpay.com/pal/servlet'
+      self.live_url = 'https://pal-live.barclaycardsmartpay.com/pal/servlet'
+
+      self.supported_countries = ['AL', 'AD', 'AM', 'AT', 'AZ', 'BY', 'BE', 'BA', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR', 'DE', 'GR', 'HU', 'IS', 'IE', 'IT', 'KZ', 'LV', 'LI', 'LT', 'LU', 'MK', 'MT', 'MD', 'MC', 'ME', 'NL', 'NO', 'PL', 'PT', 'RO', 'RU', 'SM', 'RS', 'SK', 'SI', 'ES', 'SE', 'CH', 'TR', 'UA', 'GB', 'VA']
+      self.default_currency = 'EUR'
+      self.currencies_with_three_decimal_places = %w(BHD KWD OMR RSD TND)
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :dankort, :maestro]
+
+      self.homepage_url = 'https://www.barclaycardsmartpay.com/'
+      self.display_name = 'Barclaycard Smartpay'
+
+      API_VERSION = 'v30'
+
+      def initialize(options = {})
+        requires!(options, :company, :merchant, :password)
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        MultiResponse.run do |r|
+          r.process { authorize(money, creditcard, options) }
+          r.process { capture(money, r.authorization, options) }
+        end
+      end
+
+      def authorize(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = payment_request(money, options)
+        post[:amount] = amount_hash(money, options[:currency])
+        post[:card] = credit_card_hash(creditcard)
+        post[:billingAddress] = billing_address_hash(options) if options[:billing_address]
+        post[:deliveryAddress] = shipping_address_hash(options) if options[:shipping_address]
+        add_3ds(post, options) if options[:execute_threed]
+        commit('authorise', post)
+      end
+
+      def capture(money, authorization, options = {})
+        requires!(options, :order_id)
+
+        post = modification_request(authorization, options)
+        post[:modificationAmount] = amount_hash(money, options[:currency])
+
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options = {})
+        requires!(options, :order_id)
+
+        post = modification_request(authorization, options)
+        post[:modificationAmount] = amount_hash(money, options[:currency])
+
+        commit('refund', post)
+      end
+
+      def credit(money, creditcard, options = {})
+        post = payment_request(money, options)
+        post[:amount] = amount_hash(money, options[:currency])
+        post[:card] = credit_card_hash(creditcard)
+        post[:dateOfBirth] = options[:date_of_birth] if options[:date_of_birth]
+        post[:entityType]  = options[:entity_type] if options[:entity_type]
+        post[:nationality] = options[:nationality] if options[:nationality]
+        post[:shopperName] = options[:shopper_name] if options[:shopper_name]
+
+        if options[:third_party_payout]
+          post[:recurring] = options[:recurring_contract] || {contract: 'PAYOUT'}
+          MultiResponse.run do |r|
+            r.process {
+              commit(
+                'storeDetailAndSubmitThirdParty',
+                post,
+                @options[:store_payout_account],
+                @options[:store_payout_password])
+            }
+            r.process {
+              commit(
+                'confirmThirdParty',
+                modification_request(r.authorization, @options),
+                @options[:review_payout_account],
+                @options[:review_payout_password])
+            }
+          end
+        else
+          commit('refundWithData', post)
+        end
+      end
+
+      def void(identification, options = {})
+        requires!(options, :order_id)
+
+        post = modification_request(identification, options)
+
+        commit('cancel', post)
+      end
+
+      def verify(creditcard, options = {})
+        authorize(0, creditcard, options)
+      end
+
+      def store(creditcard, options = {})
+        post = store_request(options)
+        post[:card] = credit_card_hash(creditcard)
+        post[:recurring] = {:contract => 'RECURRING'}
+
+        commit('store', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r(((?:\r\n)?Authorization: Basic )[^\r\n]+(\r\n)?), '\1[FILTERED]').
+          gsub(%r((card.number=)\d+), '\1[FILTERED]').
+          gsub(%r((card.cvc=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      # Smartpay may return AVS codes not covered by standard AVSResult codes.
+      # Smartpay's descriptions noted below.
+      AVS_MAPPING = {
+        '0'  => 'R',  # Unknown
+        '1'  => 'A',	# Address matches, postal code doesn't
+        '2'  => 'N',	# Neither postal code nor address match
+        '3'  => 'R',	# AVS unavailable
+        '4'  => 'E',	# AVS not supported for this card type
+        '5'  => 'U',	# No AVS data provided
+        '6'  => 'Z',	# Postal code matches, address doesn't match
+        '7'  => 'D',	# Both postal code and address match
+        '8'  => 'U',	# Address not checked, postal code unknown
+        '9'  => 'B',	# Address matches, postal code unknown
+        '10' => 'N',	# Address doesn't match, postal code unknown
+        '11' => 'U',	# Postal code not checked, address unknown
+        '12' => 'B',	# Address matches, postal code not checked
+        '13' => 'U',	# Address doesn't match, postal code not checked
+        '14' => 'P',	# Postal code matches, address unknown
+        '15' => 'P',	# Postal code matches, address not checked
+        '16' => 'N',	# Postal code doesn't match, address unknown
+        '17' => 'U',  # Postal code doesn't match, address not checked
+        '18' => 'I'	  # Neither postal code nor address were checked
+      }
+
+      def commit(action, post, account = 'ws', password = @options[:password])
+        request = post_data(flatten_hash(post))
+        request_headers = headers(account, password)
+        raw_response = ssl_post(build_url(action), request, request_headers)
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          test: test?,
+          avs_result: AVSResult.new(:code => parse_avs_code(response)),
+          authorization: response['recurringDetailReference'] || authorization_from(post, response)
+        )
+      rescue ResponseError => e
+        case e.response.code
+        when '401'
+          return Response.new(false, 'Invalid credentials', {}, :test => test?)
+        when '403'
+          return Response.new(false, 'Not allowed', {}, :test => test?)
+        when '422', '500'
+          if e.response.body.split(/\W+/).any? { |word| %w(validation configuration security).include?(word) }
+            error_message = e.response.body[/#{Regexp.escape('message=')}(.*?)#{Regexp.escape('&')}/m, 1].tr('+', ' ')
+            error_code = e.response.body[/#{Regexp.escape('errorCode=')}(.*?)#{Regexp.escape('&')}/m, 1]
+            return Response.new(false, error_code + ': ' + error_message, {}, :test => test?)
+          end
+        end
+        raise
+      end
+
+      def authorization_from(parameters, response)
+        authorization = [parameters[:originalReference], response['pspReference']].compact
+
+        return nil if authorization.empty?
+        return authorization.join('#')
+      end
+
+      def parse_avs_code(response)
+        AVS_MAPPING[response['avsResult'][0..1].strip] if response['avsResult']
+      end
+
+      def flatten_hash(hash, prefix = nil)
+        flat_hash = {}
+        hash.each_pair do |key, val|
+          conc_key = prefix.nil? ? key : "#{prefix}.#{key}"
+          if val.is_a?(Hash)
+            flat_hash.merge!(flatten_hash(val, conc_key))
+          else
+            flat_hash[conc_key] = val
+          end
+        end
+        flat_hash
+      end
+
+      def headers(account, password)
+        {
+          'Content-Type' => 'application/x-www-form-urlencoded; charset=utf-8',
+          'Authorization' => 'Basic ' + Base64.strict_encode64("#{account}@Company.#{@options[:company]}:#{password}").strip
+        }
+      end
+
+      def parse(response)
+        Hash[
+          response.split('&').map do |x|
+            key, val = x.split('=', 2)
+            [key.split('.').last, CGI.unescape(val)]
+          end
+        ]
+      end
+
+      def post_data(data)
+        data.map do |key, val|
+          "#{key}=#{CGI.escape(val.to_s)}"
+        end.reduce do |x, y|
+          "#{x}&#{y}"
+        end
+      end
+
+      def message_from(response)
+        return response['resultCode'] if response.has_key?('resultCode') # Payment request
+        return response['response'] if response['response'] # Modification request
+        return response['result'] if response.has_key?('result') # Store/Recurring request
+        'Failure' # Negative fallback in case of error
+      end
+
+      def success_from(response)
+        return true if response['result'] == 'Success'
+
+        successful_results = %w(Authorised Received [payout-submit-received])
+        successful_responses = %w([capture-received] [cancel-received] [refund-received] [payout-confirm-received])
+        successful_results.include?(response['resultCode']) || successful_responses.include?(response['response'])
+      end
+
+      def build_url(action)
+        case action
+        when 'store'
+          "#{test? ? self.test_url : self.live_url}/Recurring/#{API_VERSION}/storeToken"
+        when 'finalize3ds'
+          "#{test? ? self.test_url : self.live_url}/Payment/#{API_VERSION}/authorise3d"
+        when 'storeDetailAndSubmitThirdParty', 'confirmThirdParty'
+          "#{test? ? self.test_url : self.live_url}/Payout/#{API_VERSION}/#{action}"
+        else
+          "#{test? ? self.test_url : self.live_url}/Payment/#{API_VERSION}/#{action}"
+        end
+      end
+
+      def billing_address_hash(options)
+        address = options[:address] || options[:billing_address] if options[:address] || options[:billing_address]
+        street = options[:street] || parse_street(address)
+        house = options[:house_number] || parse_house_number(address)
+
+        create_address_hash(address, house, street)
+      end
+
+      def shipping_address_hash(options)
+        address = options[:shipping_address]
+        street = options[:shipping_street] || parse_street(address)
+        house = options[:shipping_house_number] || parse_house_number(address)
+
+        create_address_hash(address, house, street)
+      end
+
+      def parse_street(address)
+        address_to_parse = "#{address[:address1]} #{address[:address2]}"
+        street = address[:street] || address_to_parse.split(/\s+/).keep_if { |x| x !~ /\d/ }.join(' ')
+        street.empty? ? 'Not Provided' : street
+      end
+
+      def parse_house_number(address)
+        address_to_parse = "#{address[:address1]} #{address[:address2]}"
+        house = address[:houseNumberOrName] || address_to_parse.split(/\s+/).keep_if { |x| x =~ /\d/ }.join(' ')
+        house.empty? ? 'Not Provided' : house
+      end
+
+      def create_address_hash(address, house, street)
+        hash = {}
+        hash[:houseNumberOrName] = house
+        hash[:street]            = street
+        hash[:city]              = address[:city]
+        hash[:stateOrProvince]   = address[:state]
+        hash[:postalCode]        = address[:zip]
+        hash[:country]           = address[:country]
+        hash.keep_if { |_, v| v }
+      end
+
+      def amount_hash(money, currency)
+        currency = currency || currency(money)
+        hash = {}
+        hash[:currency] = currency
+        hash[:value]    = localized_amount(money, currency) if money
+        hash
+      end
+
+      def credit_card_hash(creditcard)
+        hash = {}
+        hash[:cvc]         = creditcard.verification_value if creditcard.verification_value
+        hash[:expiryMonth] = format(creditcard.month, :two_digits) if creditcard.month
+        hash[:expiryYear]  = format(creditcard.year, :four_digits) if creditcard.year
+        hash[:holderName]  = creditcard.name if creditcard.name
+        hash[:number]      = creditcard.number if creditcard.number
+        hash
+      end
+
+      def modification_request(reference, options)
+        hash = {}
+        hash[:merchantAccount]    = @options[:merchant]
+        hash[:originalReference]  = psp_reference_from(reference)
+        hash.keep_if { |_, v| v }
+      end
+
+      def psp_reference_from(authorization)
+        authorization.nil? ? nil : authorization.split('#').first
+      end
+
+      def payment_request(money, options)
+        hash = {}
+        hash[:merchantAccount]    = @options[:merchant]
+        hash[:reference]          = options[:order_id]
+        hash[:shopperEmail]       = options[:email]
+        hash[:shopperIP]          = options[:ip]
+        hash[:shopperReference]   = options[:customer]
+        hash[:shopperInteraction] = options[:shopper_interaction]
+        hash[:deviceFingerprint]  = options[:device_fingerprint]
+        hash.keep_if { |_, v| v }
+      end
+
+      def store_request(options)
+        hash = {}
+        hash[:merchantAccount]  = @options[:merchant]
+        hash[:shopperEmail]     = options[:email]
+        hash[:shopperReference] = options[:customer] if options[:customer]
+        hash.keep_if { |_, v| v }
+      end
+
+      def add_3ds(post, options)
+        post[:additionalData] = { executeThreeD: 'true' }
+        post[:browserInfo] = { userAgent: options[:user_agent], acceptHeader: options[:accept_header] }
+      end
+    end
+  end
+end

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

@@ -1,15 +1,15 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class BarclaysEpdqExtraPlusGateway < OgoneGateway
-      self.test_url = "https://mdepayments.epdq.co.uk/ncol/test/"
-      self.live_url = "https://payments.epdq.co.uk/ncol/prod/"
+      self.test_url = 'https://mdepayments.epdq.co.uk/ncol/test/'
+      self.live_url = 'https://payments.epdq.co.uk/ncol/prod/'
 
-      self.display_name = "Barclays ePDQ Extra Plus"
-      self.homepage_url = "http://www.barclaycard.co.uk/business/accepting-payments/epdq-ecomm/"
+      self.display_name = 'Barclays ePDQ Extra Plus'
+      self.homepage_url = 'http://www.barclaycard.co.uk/business/accepting-payments/epdq-ecomm/'
 
-      self.supported_countries = ["GB"]
+      self.supported_countries = ['GB']
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb, :maestro]
-      self.default_currency = "GBP"
+      self.default_currency = 'GBP'
     end
   end
 end