activemerchant 1.44.1 → 1.45.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/bogus.rb

@@ -13,7 +13,7 @@ module ActiveMerchant #:nodoc:
       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 = ['US']
+      self.supported_countries = []
       self.supported_cardtypes = [:bogus]
       self.homepage_url = 'http://example.com'
       self.display_name = 'Bogus'
@@ -24,7 +24,7 @@ module ActiveMerchant #:nodoc:
         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)
+          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
@@ -36,7 +36,7 @@ module ActiveMerchant #:nodoc:
         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)
+          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
@@ -53,7 +53,7 @@ module ActiveMerchant #:nodoc:
         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)
+          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
@@ -65,7 +65,7 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, REFUND_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true)
+          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
@@ -77,7 +77,7 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, CAPTURE_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true)
+          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
@@ -88,7 +88,7 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, VOID_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:authorization => reference, :error => FAILURE_MESSAGE }, :test => true)
+          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
@@ -99,7 +99,7 @@ module ActiveMerchant #:nodoc:
         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)
+          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
@@ -110,7 +110,7 @@ module ActiveMerchant #:nodoc:
         when /1$/
           Response.new(true, SUCCESS_MESSAGE, {}, :test => true)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:error => FAILURE_MESSAGE },:test => true)
+          Response.new(false, FAILURE_MESSAGE, {:error => FAILURE_MESSAGE },:test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, UNSTORE_ERROR_MESSAGE
         end

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

@@ -7,7 +7,6 @@ module ActiveMerchant #:nodoc:
 
       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.ssl_version = :SSLv3
 
       self.supported_countries = ['IS']
       self.default_currency = 'ISK'

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

@@ -500,6 +500,14 @@ module ActiveMerchant #:nodoc:
         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]
         parameters[:channel] = application_id if application_id.present? && application_id != "ActiveMerchant"
+
+        if options[:descriptor_name] || options[:descriptor_phone]
+          parameters[:descriptor] = {
+            name: options[:descriptor_name],
+            phone: options[:descriptor_phone]
+          }
+        end
+
         parameters
       end
     end

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

@@ -18,7 +18,10 @@ module ActiveMerchant #:nodoc:
       # * <tt>:password</tt> -- Password (REQUIRED)
       # * <tt>:merchant_gateway_name</tt> -- Site name (REQUIRED)
       # * <tt>:station</tt> -- Station (defaults to "WEB")
-      # * <tt>:default_item_code</tt> -- Item code (defaults to "FEE")
+      # * <tt>:custcode</tt> -- Customer code (defaults to
+      #   "ActiveMerchant/#{ActiveMerchant::VERSION}")
+      # * <tt>:default_item_code</tt> -- Default item code (defaults to "FEE",
+      #   can be overridden on a per-transaction basis with options[:item_code])
       def initialize(options = {})
         requires!(
           options,
@@ -31,18 +34,20 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def purchase(money, payment_object, fields = {})
+      def purchase(money, payment_object, options = {})
         post = {}
         add_creditcard(post, payment_object)
-        add_invoice(post, fields)
-        add_address(post, fields)
-        add_customer_data(post, fields)
+        add_invoice(post, options)
+        add_address(post, options)
+        add_customer_data(post, options)
         commit('SALE', money, post)
       end
 
-      def refund(money, identification, fields = {})
-        fields[:origtx]  = identification
-        commit('REFUND', money, fields)
+      def refund(money, identification, options = {})
+        post = {}
+        post[:origtx]  = identification
+        add_invoice(post, options)
+        commit('REFUND', money, post)
       end
 
       private
@@ -69,8 +74,7 @@ module ActiveMerchant #:nodoc:
         post[:operator]       = @options[:operator]
         post[:password]       = @options[:password]
         post[:station]        = (@options[:station] || "WEB")
-        post[:itemcode]       = (options[:item_code] || @options[:default_item_code])
-        post[:custcode]       = "ActiveMerchant/#{ActiveMerchant::VERSION}"
+        post[:custcode]       = (@options[:custcode] || "ActiveMerchant/#{ActiveMerchant::VERSION}")
         post.merge(parameters).collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
       end
 
@@ -79,10 +83,13 @@ module ActiveMerchant #:nodoc:
         post[:cid]             = creditcard.verification_value
         post[:expdate]         = expdate(creditcard)
         post[:card_name_g]     = creditcard.name
+        post[:fname]           = creditcard.first_name
+        post[:lname]           = creditcard.last_name
       end
 
       def add_invoice(post, options)
         post[:order_number]    = options[:order_id] if options[:order_id].present?
+        post[:itemcode]       = (options[:item_code] || @options[:default_item_code])
       end
 
       def add_address(post, options)

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

@@ -0,0 +1,213 @@
+require 'rubygems'
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CheckoutGateway < Gateway
+      self.default_currency = 'USD'
+      self.money_format = :decimals
+
+      self.supported_countries = ['AT', 'BE', 'BG', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GR', 'HR', 'HU', 'IE', 'IS', 'IT', 'LI', 'LT', 'LU', 'LV', 'MT', 'MU', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SK', 'US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+
+      self.homepage_url = 'https://www.checkout.com/'
+      self.display_name = 'Checkout.com'
+
+      self.live_url = 'https://api.checkout.com/Process/gateway.aspx'
+
+      ACTIONS = {
+        'purchase' => '1',
+        'authorize' => '4',
+        'capture' => '5',
+        'refund' => '2',
+        'void_purchase' => '3',
+        'void_authorize' => '9',
+        'void_capture' => '7'
+      }
+
+      def initialize(options = {})
+        @url = (options[:gateway_url] || self.live_url)
+
+        requires!(options, :merchant_id, :password)
+        super
+      end
+
+      def purchase(amount, payment_method, options)
+        requires!(options, :order_id)
+
+        commit('purchase', amount, options) do |xml|
+          add_credentials(xml, options)
+          add_invoice(xml, amount, options)
+          add_payment_method(xml, payment_method)
+          add_billing_info(xml, options)
+          add_shipping_info(xml, options)
+          add_user_defined_fields(xml, options)
+          add_other_fields(xml, options)
+        end
+      end
+
+      def authorize(amount, payment_method, options)
+        requires!(options, :order_id)
+
+        commit('authorize', amount, options) do |xml|
+          add_credentials(xml, options)
+          add_invoice(xml, amount, options)
+          add_payment_method(xml, payment_method)
+          add_billing_info(xml, options)
+          add_shipping_info(xml, options)
+          add_user_defined_fields(xml, options)
+          add_other_fields(xml, options)
+        end
+      end
+
+      def capture(amount, authorization, options = {})
+        commit('capture', amount, options) do |xml|
+          add_credentials(xml, options)
+          add_reference(xml, authorization)
+          add_invoice(xml, amount, options)
+          add_user_defined_fields(xml, options)
+          add_other_fields(xml, options)
+        end
+      end
+
+      def void(authorization, options = {})
+        _, _, orig_action, amount, currency = split_authorization(authorization)
+        commit("void_#{orig_action}") do |xml|
+          add_credentials(xml, options)
+          add_invoice(xml, amount.to_i, options.merge(currency: currency))
+          add_reference(xml, authorization)
+        end
+      end
+
+      def refund(amount, authorization, options = {})
+        commit('refund') do |xml|
+          add_credentials(xml, options)
+          add_invoice(xml, amount.to_i, options)
+          add_reference(xml, authorization)
+        end
+      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_credentials(xml, options)
+        xml.merchantid_ @options[:merchant_id]
+        xml.password_ @options[:password]
+      end
+
+      def add_invoice(xml, amount, options)
+        xml.bill_amount_ amount(amount)
+        xml.bill_currencycode_ options[:currency] || currency(amount)
+        xml.trackid_ options[:order_id] if options[:order_id]
+      end
+
+      def add_payment_method(xml, payment_method)
+        xml.bill_cardholder_ payment_method.name
+        xml.bill_cc_ payment_method.number
+        xml.bill_expmonth_ format(payment_method.month, :two_digits)
+        xml.bill_expyear_ format(payment_method.year, :four_digits)
+        if payment_method.verification_value?
+          xml.bill_cvv2_ payment_method.verification_value
+        end
+      end
+
+      def add_billing_info(xml, options)
+        if options[:billing_address]
+          xml.bill_address_ options[:billing_address][:address1]
+          xml.bill_city_    options[:billing_address][:city]
+          xml.bill_state_   options[:billing_address][:state]
+          xml.bill_postal_  options[:billing_address][:zip]
+          xml.bill_country_ options[:billing_address][:country]
+          xml.bill_phone_   options[:billing_address][:phone]
+        end
+      end
+
+      def add_shipping_info(xml, options)
+        if options[:shipping_address]
+          xml.ship_address_   options[:shipping_address][:address1]
+          xml.ship_address2_  options[:shipping_address][:address2]
+          xml.ship_city_    options[:shipping_address][:city]
+          xml.ship_state_   options[:shipping_address][:state]
+          xml.ship_postal_  options[:shipping_address][:zip]
+          xml.ship_country_   options[:shipping_address][:country]
+          xml.ship_phone_   options[:shipping_address][:phone]
+        end
+      end
+
+      def add_user_defined_fields(xml, options)
+        xml.udf1_ options[:udf1]
+        xml.udf2_ options[:udf2]
+        xml.udf3_ options[:udf3]
+        xml.udf4_ options[:udf4]
+        xml.udf5_ options[:udf5]
+      end
+
+      def add_other_fields(xml, options)
+        xml.bill_email_   options[:email]
+        xml.bill_customerip_ options[:ip]
+        xml.merchantcustomerid_ options[:customer]
+      end
+
+      def add_reference(xml, authorization)
+        transid, trackid, _, _, _ = split_authorization(authorization)
+        xml.transid transid
+        xml.trackid trackid if trackid
+      end
+
+      def commit(action, amount=nil, options={}, &builder)
+        response = parse_xml(ssl_post(@url, build_xml(action, &builder)))
+        Response.new(
+          (response[:responsecode] == "0"),
+          (response[:result] || response[:error_text] || "Unknown Response"),
+          response,
+          authorization: authorization_from(response, action, amount, options),
+          test: test?
+        )
+      end
+
+      def build_xml(action)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.request do
+            xml.action_ ACTIONS[action]
+            yield xml
+          end
+        end.to_xml
+      end
+
+      def parse_xml(xml)
+        response = {}
+
+        Nokogiri::XML(CGI.unescapeHTML(xml)).xpath("//response").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 authorization_from(response, action,  amount, options)
+        currency = options[:currency] || currency(amount)
+        [response[:tranid], response[:trackid], action, amount, currency].join("|")
+      end
+
+      def split_authorization(authorization)
+        transid, trackid, action, amount, currency = authorization.split("|")
+        [transid, trackid, action, amount, currency]
+      end
+    end
+  end
+end