activemerchant 1.47.0 → 1.48.0

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

@@ -537,12 +537,22 @@ module ActiveMerchant #:nodoc:
             :first_name => credit_card_or_vault_id.first_name,
             :last_name => credit_card_or_vault_id.last_name
           )
-          parameters[:credit_card] = {
-            :number => credit_card_or_vault_id.number,
-            :cvv => credit_card_or_vault_id.verification_value,
-            :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
-            :expiration_year => credit_card_or_vault_id.year.to_s
-          }
+          if credit_card_or_vault_id.is_a?(NetworkTokenizationCreditCard)
+            parameters[:apple_pay_card] = {
+              :number => credit_card_or_vault_id.number,
+              :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
+              :expiration_year => credit_card_or_vault_id.year.to_s,
+              :cardholder_name => "#{credit_card_or_vault_id.first_name} #{credit_card_or_vault_id.last_name}",
+              :cryptogram => credit_card_or_vault_id.payment_cryptogram
+            }
+          else
+            parameters[:credit_card] = {
+              :number => credit_card_or_vault_id.number,
+              :cvv => credit_card_or_vault_id.verification_value,
+              :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
+              :expiration_year => credit_card_or_vault_id.year.to_s
+            }
+          end
         end
         parameters[:billing] = map_address(options[:billing_address]) if options[:billing_address] && !options[:payment_method_token]
         parameters[:shipping] = map_address(options[:shipping_address]) if options[:shipping_address]

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

@@ -0,0 +1,272 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CenposGateway < Gateway
+      self.display_name = "CenPOS"
+      self.homepage_url = "https://www.cenpos.com/"
+
+      self.live_url = "https://ww3.cenpos.net/6/transact.asmx"
+
+      self.supported_countries = %w(AD AI AG AR AU AT BS BB BE BZ BM BR BN BG CA HR CY CZ DK DM EE FI FR DE GR GD GY HK HU IS IN IL IT JP LV LI LT LU MY MT MX MC MS NL PA PL PT KN LC MF VC SM SG SK SI ZA ES SR SE CH TR GB US UY)
+      self.default_currency = "USD"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :password, :user_id)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit("Sale", post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit("Auth", post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit("SpecialForce", post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_void_required_elements(post)
+        add_reference(post, authorization)
+        commit("Void", post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit("SpecialReturn", post)
+      end
+
+      def credit(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+
+        commit("Credit", 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((<acr1:CardNumber>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<acr1:CardVerificationNumber>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<acr:Password>)[^<]+(<))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
+      CURRENCY_CODES["AUD"] = "036"
+      CURRENCY_CODES["CAD"] = "124"
+      CURRENCY_CODES["CHF"] = "756"
+      CURRENCY_CODES["CZK"] = "203"
+      CURRENCY_CODES["DKK"] = "208"
+      CURRENCY_CODES["EUR"] = "978"
+      CURRENCY_CODES["GBP"] = "826"
+      CURRENCY_CODES["HKD"] = "344"
+      CURRENCY_CODES["HUF"] = "348"
+      CURRENCY_CODES["IRR"] = "364"
+      CURRENCY_CODES["JPY"] = "392"
+      CURRENCY_CODES["LVL"] = "428"
+      CURRENCY_CODES["MYR"] = "458"
+      CURRENCY_CODES["NOK"] = "578"
+      CURRENCY_CODES["PLN"] = "985"
+      CURRENCY_CODES["SEK"] = "752"
+      CURRENCY_CODES["SGD"] = "702"
+      CURRENCY_CODES["USD"] = "840"
+      CURRENCY_CODES["ZAR"] = "710"
+
+      def add_invoice(post, money, options)
+        post[:Amount] = amount(money)
+        post[:CurrencyCode] = CURRENCY_CODES[options[:currency] || currency(money)]
+        post[:TaxAmount] = amount(options[:tax])
+        post[:InvoiceNumber] = options[:order_id]
+        post[:InvoiceDetail] = options[:description]
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:NameOnCard] = payment_method.name
+        post[:CardNumber] = payment_method.number
+        post[:CardVerificationNumber] = payment_method.verification_value
+        post[:CardExpirationDate] = format(payment_method.month, :two_digits) + format(payment_method.year, :two_digits)
+        post[:CardLastFourDigits] = payment_method.last_digits
+        post[:MagneticData] = payment_method.track_data
+      end
+
+      def add_customer_data(post, options)
+        if(billing_address = (options[:billing_address] || options[:address]))
+          post[:CustomerEmailAddress] = billing_address[:email]
+          post[:CustomerPhone] = billing_address[:phone]
+          post[:CustomerBillingAddress] = billing_address[:address1]
+          post[:CustomerCity] = billing_address[:city]
+          post[:CustomerState] = billing_address[:state]
+          post[:CustomerZipCode] = billing_address[:zip]
+        end
+      end
+
+      def add_void_required_elements(post)
+        post[:GeoLocationInformation] = nil
+        post[:IMEI] = nil
+      end
+
+      def add_reference(post, authorization)
+        reference_number, last_four_digits, original_amount = split_authorization(authorization)
+        post[:ReferenceNumber] = reference_number
+        post[:CardLastFourDigits] = last_four_digits
+        post[:Amount] = original_amount
+      end
+
+      def commit(action, post)
+        post[:MerchantId] = @options[:merchant_id]
+        post[:Password] = @options[:password]
+        post[:UserId] = @options[:user_id]
+        post[:TransactionType] = action
+
+        data = build_request(post)
+        begin
+          raw = parse(ssl_post(self.live_url, data, headers))
+        rescue ActiveMerchant::ResponseError => e
+          if(e.response.code == "500" && e.response.body.start_with?("<s:Envelope"))
+            raw = {
+              message: "See transcript for detailed error description."
+            }
+          else
+            raise
+          end
+        end
+
+        succeeded = success_from(raw[:result])
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          authorization: authorization_from(post, raw),
+          error_code: error_code_from(succeeded, raw),
+          test: test?
+        )
+      end
+
+      def headers
+        {
+          "Accept-Encoding" => "gzip,deflate",
+          "Content-Type"  => "text/xml;charset=UTF-8",
+          "SOAPAction"  => "http://tempuri.org/Transactional/ProcessCard"
+        }
+      end
+
+      def build_request(post)
+        xml = Builder::XmlMarkup.new :indent => 8
+        xml.tag!("acr:MerchantId", post.delete(:MerchantId))
+        xml.tag!("acr:Password", post.delete(:Password))
+        xml.tag!("acr:UserId", post.delete(:UserId))
+        post.sort.each do |field, value|
+          xml.tag!("acr1:#{field}", value)
+        end
+        envelope(xml.target!)
+      end
+
+      def envelope(body)
+        <<-EOS
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/" xmlns:acr="http://schemas.datacontract.org/2004/07/Acriter.ABI.CenPOS.EPayment.VirtualTerminal.Common" xmlns:acr1="http://schemas.datacontract.org/2004/07/Acriter.ABI.CenPOS.EPayment.VirtualTerminal.v6.Common" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+<soapenv:Header/>
+   <soapenv:Body>
+      <tem:ProcessCard>
+         <tem:request>
+           #{body}
+         </tem:request>
+      </tem:ProcessCard>
+   </soapenv:Body>
+</soapenv:Envelope>
+        EOS
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.remove_namespaces!
+        body = doc.xpath("//ProcessCardResult")
+        body.children.each do |node|
+          if (node.elements.size == 0)
+            response[node.name.underscore.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name.underscore}_#{childnode.name.underscore}"
+              response[name.to_sym] = childnode.text
+            end
+          end
+        end unless doc.root.nil?
+
+        response
+      end
+
+      def success_from(response)
+        response == "0"
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response[:message] || "Unable to read error message"
+        end
+      end
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        "211" => STANDARD_ERROR_CODE[:invalid_number],
+        "252" => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        "257" => STANDARD_ERROR_CODE[:invalid_cvc],
+        "333" => STANDARD_ERROR_CODE[:expired_card],
+        "1" => STANDARD_ERROR_CODE[:card_declined],
+        "99" => STANDARD_ERROR_CODE[:processing_error],
+      }
+
+      def authorization_from(request, response)
+        [ response[:reference_number], request[:CardLastFourDigits], request[:Amount] ].join("|")
+      end
+
+      def split_authorization(authorization)
+        reference_number, last_four_digits, original_amount = authorization.split("|")
+        [reference_number, last_four_digits, original_amount]
+      end
+
+      def error_code_from(succeeded, response)
+        succeeded ? nil : STANDARD_ERROR_CODE_MAPPING[response[:result]]
+      end
+    end
+  end
+end

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

@@ -1,8 +1,7 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class EpayGateway < Gateway
-      API_HOST = 'ssl.ditonlinebetalingssystem.dk'
-      self.live_url = 'https://' + API_HOST + '/remote/payment'
+      self.live_url = 'https://ssl.ditonlinebetalingssystem.dk/'
 
       self.default_currency = 'DKK'
       self.money_format = :cents
@@ -175,14 +174,14 @@ module ActiveMerchant #:nodoc:
       def soap_post(method, params)
         data = xml_builder(params, method)
         headers = make_headers(data, method)
-        REXML::Document.new(ssl_post('https://' + API_HOST + '/remote/payment.asmx', data, headers))
+        REXML::Document.new(ssl_post(live_url + 'remote/payment.asmx', data, headers))
       end
 
       def do_authorize(params)
         headers = {}
         headers['Referer'] = (options[:password] || "activemerchant.org")
 
-        response = raw_ssl_request(:post, 'https://' + API_HOST + '/auth/default.aspx', authorize_post_data(params), headers)
+        response = raw_ssl_request(:post, live_url + 'auth/default.aspx', authorize_post_data(params), headers)
 
         # Authorize gives the response back by redirecting with the values in
         # the URL query
@@ -233,9 +232,9 @@ module ActiveMerchant #:nodoc:
       def make_headers(data, soap_call)
         {
           'Content-Type' => 'text/xml; charset=utf-8',
-          'Host' => API_HOST,
+          'Host' => "ssl.ditonlinebetalingssystem.dk",
           'Content-Length' => data.size.to_s,
-          'SOAPAction' => self.live_url + '/' + soap_call
+          'SOAPAction' => self.live_url + 'remote/payment/' + soap_call
         }
       end
 
@@ -246,7 +245,7 @@ module ActiveMerchant #:nodoc:
                                       'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
                                       'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/' } do
             xml.tag! 'soap:Body' do
-              xml.tag! soap_call, { 'xmlns' => self.live_url } do
+              xml.tag! soap_call, { 'xmlns' => "#{self.live_url}remote/payment" } do
                 xml.tag! 'merchantnumber', @options[:login]
                 xml.tag! 'transactionid', params[:transaction]
                 xml.tag! 'amount', params[:amount].to_s if soap_call != 'delete'
@@ -259,8 +258,8 @@ module ActiveMerchant #:nodoc:
       def authorize_post_data(params = {})
         params[:language] = '2'
         params[:cms] = 'activemerchant'
-        params[:accepturl] = 'https://ssl.ditonlinebetalingssystem.dk/auth/default.aspx?accept=1'
-        params[:declineurl] = 'https://ssl.ditonlinebetalingssystem.dk/auth/default.aspx?decline=1'
+        params[:accepturl] = live_url + 'auth/default.aspx?accept=1'
+        params[:declineurl] = live_url + 'auth/default.aspx?decline=1'
         params[:merchantnumber] = @options[:login]
 
         params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")

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

@@ -68,6 +68,7 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+
       def build_request(action, body)
         xml = Builder::XmlMarkup.new
 
@@ -168,6 +169,14 @@ module ActiveMerchant #:nodoc:
            :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)

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

@@ -38,12 +38,35 @@ module ActiveMerchant #:nodoc:
 
         add_amount(post, money, options)
         add_creditcard(post, creditcard, options)
+        add_extra_options(post, options)
         post[:reference] = options[:order_id]
         post[:customer_ip] = options[:ip]
 
         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)
+        post[:capture] = false
+        post[:reference] = options[:order_id]
+        post[:customer_ip] = options[:ip]
+
+        commit(:post, 'purchases', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_amount(post, money, options)
+        add_extra_options(post, options)
+
+
+        commit(:post, "purchases/#{CGI.escape(authorization)}/capture", post)
+      end
+
       # Refund a transaction
       #
       # amount - Integer - the amount to refund
@@ -52,6 +75,7 @@ module ActiveMerchant #:nodoc:
       def refund(money, txn_id, reference)
         post = {}
 
+        add_extra_options(post, options)
         post[:amount] = money
         post[:transaction_id] = txn_id
         post[:reference] = reference
@@ -73,6 +97,8 @@ module ActiveMerchant #:nodoc:
 
       # Add the money details to the request
       def add_amount(post, money, options)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:currency] = post[:currency].upcase if post[:currency]
         post[:amount] = money
       end
 
@@ -95,6 +121,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_extra_options(post, options)
+        extra = {}
+        extra[:name] = options[:merchant] if options[:merchant]
+        extra[:location] = options[:merchant_location] if options[:merchant_location]
+        post[:extra] = extra if extra.any?
+      end
+
       # Post the data to the gateway
       def commit(method, uri, parameters=nil)
         response = begin