activemerchant 1.28.0 → 1.29.0

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

@@ -6,24 +6,24 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://demo.viaklix.com/process.asp'
       self.live_url = 'https://www.viaklix.com/process.asp'
       self.delimiter = "\r\n"
-      
+
       self.actions = {
         :purchase => 'SALE',
         :credit => 'CREDIT'
       }
-      
+
       APPROVED = '0'
-      
+
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.supported_countries = ['US']
       self.display_name = 'ViaKLIX'
       self.homepage_url = 'http://viaklix.com'
-      
+
       # Initialize the Gateway
       #
       # The gateway requires that a valid login and password be passed
       # in the +options+ hash.
-      # 
+      #
       # ==== Options
       #
       # * <tt>:login</tt> -- Merchant ID
@@ -32,55 +32,54 @@ module ActiveMerchant #:nodoc:
       # * <tt>:test => +true+ or +false+</tt> -- Force test transactions
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
-      
-      # Make a purchase  
+
+      # Make a purchase
       def purchase(money, creditcard, options = {})
         form = {}
         add_invoice(form, options)
-        add_creditcard(form, creditcard)        
-        add_address(form, options)   
+        add_creditcard(form, creditcard)
+        add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
         commit(:purchase, money, form)
       end
-      
+
       # Make a credit to a card (Void can only be done from the virtual terminal)
       # Viaklix does not support credits by reference. You must pass in the credit card
       def credit(money, creditcard, options = {})
         if creditcard.is_a?(String)
           raise ArgumentError, "Reference credits are not supported. Please supply the original credit card"
         end
-        
+
         form = {}
         add_invoice(form, options)
-        add_creditcard(form, creditcard)        
-        add_address(form, options)   
+        add_creditcard(form, creditcard)
+        add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
         commit(:credit, money, form)
       end
-      
+
       private
       def add_test_mode(form, options)
         form[:test_mode] = 'TRUE' if options[:test_mode]
       end
-      
+
       def add_customer_data(form, options)
         form[:email] = options[:email].to_s.slice(0, 100) unless options[:email].blank?
         form[:customer_code] = options[:customer].to_s.slice(0, 10) unless options[:customer].blank?
       end
-      
+
       def add_invoice(form,options)
         form[:invoice_number] = (options[:order_id] || options[:invoice]).to_s.slice(0, 10)
         form[:description] = options[:description].to_s.slice(0, 255)
       end
-      
+
       def add_address(form,options)
-        billing_address = options[:billing_address] || options[:address] 
-        
+        billing_address = options[:billing_address] || options[:address]
+
         if billing_address
           form[:avs_address]    = billing_address[:address1].to_s.slice(0, 30)
           form[:address2]       = billing_address[:address2].to_s.slice(0, 30)
@@ -91,7 +90,7 @@ module ActiveMerchant #:nodoc:
           form[:phone]          = billing_address[:phone].to_s.slice(0, 20)
           form[:country]        = billing_address[:country].to_s.slice(0, 50)
         end
-                
+
         if shipping_address = options[:shipping_address]
           first_name, last_name = parse_first_and_last_name(shipping_address[:name])
           form[:ship_to_first_name]     = first_name.to_s.slice(0, 20)
@@ -104,82 +103,78 @@ module ActiveMerchant #:nodoc:
           form[:ship_to_zip]            = shipping_address[:zip].to_s.slice(0, 10)
         end
       end
-      
+
       def parse_first_and_last_name(value)
         name = value.to_s.split(' ')
-        
+
         last_name = name.pop || ''
         first_name = name.join(' ')
-        [ first_name, last_name ] 
+        [ first_name, last_name ]
       end
-      
+
       def add_creditcard(form, creditcard)
         form[:card_number] = creditcard.number
         form[:exp_date] = expdate(creditcard)
-        
+
         if creditcard.verification_value?
           add_verification_value(form, creditcard)
         end
-        
+
         form[:first_name] = creditcard.first_name.to_s.slice(0, 20)
         form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
       end
-      
+
       def add_verification_value(form, creditcard)
-        form[:cvv2cvc2] = creditcard.verification_value 
+        form[:cvv2cvc2] = creditcard.verification_value
         form[:cvv2] = 'present'
       end
-      
+
       def preamble
         result = {
           'merchant_id'   => @options[:login],
           'pin'           => @options[:password],
           'show_form'     => 'false',
-          'result_format' => 'ASCII'          
+          'result_format' => 'ASCII'
         }
-        
+
         result['user_id'] = @options[:user] unless @options[:user].blank?
         result
       end
-      
-      def test?
-        @options[:test] || super
-      end
-      
+
       def commit(action, money, parameters)
         parameters[:amount] = amount(money)
         parameters[:transaction_type] = self.actions[action]
-            
+
         response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)) )
 
-        Response.new(response['result'] == APPROVED, message_from(response), response, 
-          :test => @options[:test] || test?, 
+        Response.new(response['result'] == APPROVED, message_from(response), response,
+          :test => @options[:test] || test?,
           :authorization => authorization_from(response),
           :avs_result => { :code => response['avs_response'] },
           :cvv_result => response['cvv2_response']
         )
       end
-      
+
       def authorization_from(response)
         response['txn_id']
       end
-      
+
       def message_from(response)
         response['result_message']
       end
-      
+
       def post_data(parameters)
         result = preamble
-        result.merge!(parameters)        
+        result.merge!(parameters)
         result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
       end
-      
+
       def expdate(creditcard)
         year  = sprintf("%.4i", creditcard.year)
         month = sprintf("%.2i", creditcard.month)
         "#{month}#{year[2..3]}"
       end
-      
+
       # Parse the response message
       def parse(msg)
         resp = {}
@@ -191,4 +186,4 @@ module ActiveMerchant #:nodoc:
       end
     end
   end
-end
+end

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

@@ -4,12 +4,14 @@ rescue LoadError
   raise "Could not load the vindicia-api gem.  Use `gem install vindicia-api` to install it."
 end
 
+require 'i18n/core_ext/string/interpolate'
+
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
 
     # For more information on the Vindicia Gateway please visit their {website}[http://vindicia.com/]
     #
-    # The login and password are not the username and password you use to 
+    # The login and password are not the username and password you use to
     # login to the Vindicia Merchant Portal.
     #
     # ==== Recurring Billing
@@ -25,8 +27,8 @@ module ActiveMerchant #:nodoc:
 
       class_attribute :test_url, :live_url
 
-      self.test_url = "https://soap.prodtest.sj.vindicia.com/soap.pl" 
-      self.live_url = "http://soap.vindicia.com/soap.pl" 
+      self.test_url = "https://soap.prodtest.sj.vindicia.com/soap.pl"
+      self.live_url = "http://soap.vindicia.com/soap.pl"
 
       # Creates a new VindiciaGateway
       #
@@ -40,24 +42,25 @@ module ActiveMerchant #:nodoc:
       # * <tt>:api_version</tt> -- Vindicia API Version - defaults to 3.6 (OPTIONAL)
       # * <tt>:account_id</tt> -- Account Id which all transactions will be run against. (REQUIRED)
       # * <tt>:transaction_prefix</tt> -- Prefix to order id for one-time transactions - defaults to 'X' (OPTIONAL
-      # * <tt>:min_chargeback_probability</tt> -- Minimum score for chargebacks - defaults to 65 (OPTIONAL) 
+      # * <tt>:min_chargeback_probability</tt> -- Minimum score for chargebacks - defaults to 65 (OPTIONAL)
       # * <tt>:cvn_success</tt> -- Array of valid CVN Check return values - defaults to [M, P] (OPTIONAL)
       # * <tt>:avs_success</tt> -- Array of valid AVS Check return values - defaults to [X, Y, A, W, Z] (OPTIONAL)
       def initialize(options = {})
         requires!(options, :login, :password)
+        super
 
         config = lambda do |config|
-          config.login = options[:login] 
-          config.password = options[:password] 
+          config.login = options[:login]
+          config.password = options[:password]
           config.api_version = options[:api_version] || "3.6"
-          config.endpoint = test? ? self.test_url : self.live_url 
+          config.endpoint = test? ? self.test_url : self.live_url
           config.namespace = "http://soap.vindicia.com"
         end
 
-        if Vindicia.config.is_configured? 
+        if Vindicia.config.is_configured?
           config.call(Vindicia.config)
         else
-          Vindicia.configure(&config) 
+          Vindicia.configure(&config)
         end
 
         requires!(options, :account_id)
@@ -66,10 +69,9 @@ module ActiveMerchant #:nodoc:
         @transaction_prefix = options[:transaction_prefix] || "X"
 
         @min_chargeback_probability = options[:min_chargeback_probability] || 65
-        @cvn_success = options[:cvn_success] || %w{M P} 
+        @cvn_success = options[:cvn_success] || %w{M P}
         @avs_success = options[:avs_success] || %w{X Y A W Z}
 
-        @options = options
         @allowed_authorization_statuses = %w{Authorized}
       end
 
@@ -103,7 +105,7 @@ module ActiveMerchant #:nodoc:
         if !response.success? && response.fraud_review? && !response.authorization.blank?
           void_response = void([vindicia_transaction[:transaction][:merchantTransactionId]], options)
           if void_response.success?
-            return response 
+            return response
           else
             return void_response
           end
@@ -142,10 +144,10 @@ module ActiveMerchant #:nodoc:
             :account => { :merchantAccountId => @account_id },
             :merchantTransactionId => identification,
             :sourceIp => options[:ip]
-          }] 
+          }]
         }))
 
-        if response[:return][:returnCode] == '200' && response[:qtyFail].to_i == 0          
+        if response[:return][:returnCode] == '200' && response[:qtyFail].to_i == 0
           success(response, identification)
         else
           fail(response)
@@ -204,22 +206,22 @@ module ActiveMerchant #:nodoc:
 
       def check_transaction(vindicia_transaction)
         if vindicia_transaction[:return][:returnCode] == '200'
-          status_log = vindicia_transaction[:transaction][:statusLog].first 
+          status_log = vindicia_transaction[:transaction][:statusLog].first
           if status_log[:creditCardStatus]
             avs = status_log[:creditCardStatus][:avsCode]
             cvn = status_log[:creditCardStatus][:cvnCode]
           end
 
-          if @allowed_authorization_statuses.include?(status_log[:status]) && 
+          if @allowed_authorization_statuses.include?(status_log[:status]) &&
             check_cvn(cvn) && check_avs(avs)
 
-            success(vindicia_transaction, 
-                    vindicia_transaction[:transaction][:merchantTransactionId], 
+            success(vindicia_transaction,
+                    vindicia_transaction[:transaction][:merchantTransactionId],
                     avs, cvn)
           else
             # If the transaction is authorized, but it didn't pass our AVS/CVV checks send the authorization along so
             # that is gets voided. Otherwise, send no authorization.
-            fail(vindicia_transaction, avs, cvn, false, 
+            fail(vindicia_transaction, avs, cvn, false,
                  @allowed_authorization_statuses.include?(status_log[:status]) ? vindicia_transaction[:transaction][:merchantTransactionId] : "")
           end
         else
@@ -238,9 +240,9 @@ module ActiveMerchant #:nodoc:
         add_customer_data(parameters, options)
         add_payment_source(parameters, creditcard, options)
 
-        post(Vindicia::Transaction.auth({ 
-          :transaction => parameters, 
-          :minChargebackProbability => @min_chargeback_probability 
+        post(Vindicia::Transaction.auth({
+          :transaction => parameters,
+          :minChargebackProbability => @min_chargeback_probability
         }))
       end
 
@@ -281,8 +283,8 @@ module ActiveMerchant #:nodoc:
         add_subscription_information(parameters, options)
 
         post(Vindicia::AutoBill.update({
-          :autobill => parameters, 
-          :validatePaymentMethod => false, 
+          :autobill => parameters,
+          :validatePaymentMethod => false,
           :minChargebackProbability => 100
         }))
       end
@@ -290,8 +292,8 @@ module ActiveMerchant #:nodoc:
       def check_subscription(vindicia_transaction)
         if vindicia_transaction[:return][:returnCode] == '200'
           if vindicia_transaction[:autobill] && vindicia_transaction[:autobill][:status] == "Active"
-            success(vindicia_transaction, 
-                    vindicia_transaction[:autobill][:merchantAutoBillId]) 
+            success(vindicia_transaction,
+                    vindicia_transaction[:autobill][:merchantAutoBillId])
           else
             fail(vindicia_transaction)
           end
@@ -326,8 +328,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def fail(response, avs_code = nil, cvn_code = nil, fraud_review = false, authorization = "")
-        ActiveMerchant::Billing::Response.new(false, response[:return][:returnString], response, 
-                                              { :fraud_review => fraud_review || !authorization.blank?, 
+        ActiveMerchant::Billing::Response.new(false, response[:return][:returnString], response,
+                                              { :fraud_review => fraud_review || !authorization.blank?,
                                                 :authorization => authorization, :test => test?,
                                                 :avs_result => { :code => avs_code }, :cvv_result => cvn_code })
 

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

@@ -0,0 +1,45 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WebpayGateway < StripeGateway
+      self.live_url = 'https://api.webpay.jp/v1/'
+
+      self.supported_countries = ['JP']
+      self.default_currency = 'JPY'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :jcb, :diners_club]
+
+      self.homepage_url = 'https://webpay.jp/'
+      self.display_name = 'WebPay'
+
+      def json_error(raw_response)
+        msg = 'Invalid response received from the WebPay API.  Please contact support@webpay.jp if you continue to receive this message.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        {
+          "error" => {
+            "message" => msg
+          }
+        }
+      end
+
+      def headers(meta={})
+        @@ua ||= JSON.dump({
+          :bindings_version => ActiveMerchant::VERSION,
+          :lang => 'ruby',
+          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+          :platform => RUBY_PLATFORM,
+          :publisher => 'active_merchant',
+          :uname => (RUBY_PLATFORM =~ /linux|darwin/i ? `uname -a 2>/dev/null`.strip : nil)
+        })
+
+        {
+          "Authorization" => "Basic " + Base64.encode64(@api_key.to_s + ":").strip,
+          "User-Agent" => "Webpay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "X-Webpay-Client-User-Agent" => @@ua,
+          "X-Webpay-Client-User-Metadata" => meta.to_json
+        }
+      end
+    end
+  end
+end

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

@@ -57,15 +57,9 @@ module ActiveMerchant #:nodoc:
         requires!(options, :login, :password)
         # unfortunately Wirecard also requires a BusinessCaseSignature in the XML request
         requires!(options, :signature)
-        @options = options
         super
       end
 
-      # Should run against the test servers or not?
-      def test?
-        @options[:test] || super
-      end
-
       # Authorization
       def authorize(money, creditcard, options = {})
         options[:credit_card] = creditcard

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

@@ -20,12 +20,11 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
 
       def purchase(money, payment_method, options = {})
-        MultiResponse.new.tap do |r|
+        MultiResponse.run do |r|
           r.process{authorize(money, payment_method, options)}
           r.process{capture(money, r.authorization, options.merge(:authorization_validated => true))}
         end
@@ -37,30 +36,26 @@ module ActiveMerchant #:nodoc:
       end
 
       def capture(money, authorization, options = {})
-        MultiResponse.new.tap do |r|
+        MultiResponse.run do |r|
           r.process{inquire_request(authorization, options, "AUTHORISED")} unless options[:authorization_validated]
           r.process{capture_request(money, authorization, options)}
         end
       end
 
       def void(authorization, options = {})
-        MultiResponse.new.tap do |r|
+        MultiResponse.run do |r|
           r.process{inquire_request(authorization, options, "AUTHORISED")}
           r.process{cancel_request(authorization, options)}
         end
       end
 
       def refund(money, authorization, options = {})
-        MultiResponse.new.tap do |r|
+        MultiResponse.run do |r|
           r.process{inquire_request(authorization, options, "CAPTURED")}
           r.process{refund_request(money, authorization, options)}
         end
       end
 
-      def test?
-        @options[:test] || super  
-      end
-
       private
 
       def authorize_request(money, payment_method, options)