activemerchant 1.42.6 → 1.90.0

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

@@ -3,23 +3,22 @@ module ActiveMerchant #: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"
+      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" }
+      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",
+      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/'
                                    }
 
@@ -27,11 +26,11 @@ module ActiveMerchant #:nodoc:
                                             'xsi:type' => 'n2:Transaction'
                                           }
 
-      POST_HEADERS = { 'soapAction' => "http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/SendAndCommit",
+      POST_HEADERS = { 'soapAction' => 'http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/SendAndCommit',
                        'Content-Type' => 'text/xml'
                      }
 
-      SUCCESS = "true"
+      SUCCESS = 'true'
 
       SENSITIVE_FIELDS = [ :verification_str2, :expiry_date, :card_number ]
 
@@ -59,7 +58,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, authorization, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, authorization, options)
       end
 
@@ -68,6 +67,7 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+
       def build_request(action, body)
         xml = Builder::XmlMarkup.new
 
@@ -160,14 +160,21 @@ module ActiveMerchant #:nodoc:
       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]
-         )
+        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)
@@ -176,9 +183,9 @@ module ActiveMerchant #:nodoc:
 
       def authorization_from(response)
         if response[:authorization_num] && response[:transaction_tag]
-           "#{response[:authorization_num]};#{response[:transaction_tag]}"
+          "#{response[:authorization_num]};#{response[:transaction_tag]}"
         else
-           ''
+          ''
         end
       end
 
@@ -198,13 +205,13 @@ module ActiveMerchant #:nodoc:
         response = {}
         xml = REXML::Document.new(xml)
 
-        if root = REXML::XPath.first(xml, "//types:TransactionResult")
+        if root = REXML::XPath.first(xml, '//types:TransactionResult')
           parse_elements(response, root)
-        elsif root = REXML::XPath.first(xml, "//soap:Fault")
+        elsif root = REXML::XPath.first(xml, '//soap:Fault')
           parse_elements(response, root)
         end
 
-        response.delete_if{ |k,v| SENSITIVE_FIELDS.include?(k) }
+        response.delete_if { |k, v| SENSITIVE_FIELDS.include?(k) }
       end
 
       def parse_elements(response, root)
@@ -215,4 +222,3 @@ module ActiveMerchant #:nodoc:
     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 = [: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

@@ -3,8 +3,8 @@ 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.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'
@@ -14,69 +14,82 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://www.fatzebra.com.au/'
       self.display_name = 'Fat Zebra'
 
-      # Setup a new instance of the gateway.
-      #
-      # The options hash should include :username and :token
-      # You can find your username and token at https://dashboard.fatzebra.com.au
-      # Under the Your Account section
       def initialize(options = {})
         requires!(options, :username, :token)
-        @username = options[:username]
-        @token    = options[:token]
         super
       end
 
-      # To create a purchase on a credit card use:
-      #
-      #   purchase(money, creditcard)
-      #
-      # To charge a tokenized card
-      #
-      #   purchase(money, "abzy87u", :cvv => "123")
       def purchase(money, creditcard, options = {})
         post = {}
 
         add_amount(post, money, options)
         add_creditcard(post, creditcard, options)
-        post[:reference] = options[:order_id]
-        post[:customer_ip] = options[:ip]
+        add_extra_options(post, options)
+        add_order_id(post, options)
+        add_ip(post, options)
 
         commit(:post, 'purchases', post)
       end
 
-      # Refund a transaction
-      #
-      # amount - Integer - the amount to refund
-      # txn_id - String - the original transaction to be refunded
-      # reference - String - your transaction reference
-      def refund(money, txn_id, reference)
+      def authorize(money, creditcard, options = {})
         post = {}
 
-        post[:amount] = money
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        add_extra_options(post, options)
+        add_order_id(post, options)
+        add_ip(post, options)
+
+        post[:capture] = false
+
+        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
+
+      def refund(money, txn_id, options={})
+        post = {}
+
+        add_extra_options(post, options)
+        add_amount(post, money, options)
         post[:transaction_id] = txn_id
-        post[:reference] = reference
+        add_order_id(post, options)
 
-        commit(:post, "refunds", post)
+        commit(:post, 'refunds', post)
       end
 
-      # Tokenize a credit card
-      #
-      # The token is returned in the Response#authorization
-      def store(creditcard)
+      def store(creditcard, options={})
         post = {}
         add_creditcard(post, creditcard)
 
-        commit(:post, "credit_cards", post)
+        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
 
-      # 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
 
-      # Add the credit card details to the request
       def add_creditcard(post, creditcard, options = {})
         if creditcard.respond_to?(:number)
           post[:card_number] = creditcard.number
@@ -87,7 +100,7 @@ module ActiveMerchant #:nodoc:
           post[:card_token] = creditcard
           post[:cvv] = options[:cvv]
         elsif creditcard.is_a?(Hash)
-          deprecated "Passing the credit card as a Hash is deprecated. Use a String and put the (optional) CVV in the options hash instead."
+          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
@@ -95,12 +108,30 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      # Post the data to the gateway
+      def add_extra_options(post, options)
+        extra = {}
+        extra[:ecm] = '32' if options[:recurring]
+        extra[:cavv] = options[:cavv] if options[:cavv]
+        extra[:xid] = options[:xid] if options[:xid]
+        extra[:sli] = options[:sli] if options[:sli]
+        extra[:name] = options[:merchant] if options[:merchant]
+        extra[:location] = options[:merchant_location] if options[:merchant_location]
+        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 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")
+          return Response.new(false, 'Invalid Login') if(e.response.code == '401')
           parse(e.response.body)
         end
 
@@ -109,63 +140,58 @@ module ActiveMerchant #:nodoc:
           success,
           message_from(response),
           response,
-          :test => response["test"],
+          :test => response['test'],
           :authorization => authorization_from(response, success)
         )
       end
 
       def success_from(response)
         (
-          response["successful"] &&
-          response["response"] &&
-          (response["response"]["successful"] || response["response"]["token"])
+          response['successful'] &&
+          response['response'] &&
+          (response['response']['successful'] || response['response']['token'])
         )
       end
 
       def authorization_from(response, success)
         if success
-          (response["response"]["id"] || response["response"]["token"])
+          (response['response']['id'] || response['response']['token'])
         else
           nil
         end
       end
 
       def message_from(response)
-        if !response["errors"].empty?
-          response["errors"].join(", ")
-        elsif response["response"]["message"]
-          response["response"]["message"]
+        if !response['errors'].empty?
+          response['errors'].join(', ')
+        elsif response['response']['message']
+          response['response']['message']
         else
-          "Unknown Error"
+          'Unknown Error'
         end
       end
 
-      # Parse the returned JSON, if parse errors are raised then return a detailed error.
       def parse(response)
-        begin
-          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
+        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
 
-      # Build the URL based on the AM mode and the URI
       def get_url(uri)
         base = test? ? self.test_url : self.live_url
-        base + "/" + uri
+        base + '/' + uri
       end
 
-      # Builds the auth and U-A headers for the request
       def headers
         {
-          "Authorization" => "Basic " + Base64.strict_encode64(@username.to_s + ":" + @token.to_s).strip,
-          "User-Agent" => "Fat Zebra v1.0/ActiveMerchant #{ActiveMerchant::VERSION}"
+          '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

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

@@ -58,7 +58,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, authorization, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, authorization, options)
       end
 
@@ -107,12 +107,6 @@ module ActiveMerchant #:nodoc:
         post[:cvv] = creditcard.verification_value
       end
 
-      def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-        "#{month}#{year[-2..-1]}"
-      end
-
       def parse(body)
         body.split('&').inject({}) do |memo, x|
           k, v = x.split('=')
@@ -126,7 +120,6 @@ module ActiveMerchant #:nodoc:
         data = ssl_post(self.live_url, post_data(action, parameters))
         response = parse(data)
         message = message_from(response)
-        test_mode = test?
 
         Response.new(success?(response), message, response,
           :test => test?,
@@ -141,17 +134,17 @@ module ActiveMerchant #:nodoc:
       end
 
       def test?
-        (@options[:login].eql?('demo')) && (@options[:password].eql?('password'))
+        @options[:login].eql?('demo') && @options[:password].eql?('password')
       end
 
       def message_from(response)
         case response['response'].to_i
         when APPROVED
-          "Transaction Approved"
+          'Transaction Approved'
         when DECLINED
-          "Transaction Declined"
+          'Transaction Declined'
         else
-          "Error in transaction data or system error"
+          'Error in transaction data or system error'
         end
       end
 
@@ -159,9 +152,8 @@ module ActiveMerchant #:nodoc:
         parameters[:type] = action
         parameters[:username] = @options[:login]
         parameters[:password] = @options[:password]
-        parameters.map{|k, v| "#{k}=#{CGI.escape(v.to_s)}"}.join('&')
+        parameters.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
       end
     end
   end
 end
-

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

@@ -1,9 +1,10 @@
-require File.dirname(__FILE__) + '/cc5'
+require 'active_merchant/billing/gateways/cc5'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class FinansbankGateway < CC5Gateway
-      self.live_url = self.test_url = 'https://www.fbwebpos.com/servlet/cc5ApiServer'
+      self.live_url =  'https://www.fbwebpos.com/servlet/cc5ApiServer'
+      self.test_url = 'https://entegrasyon.asseco-see.com.tr/fim/api'
 
       # The countries the gateway supports merchants from as 2 digit ISO country codes
       self.supported_countries = ['US', 'TR']
@@ -19,4 +20,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-