activemerchant 1.100.0 → 1.133.0

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

@@ -4,19 +4,20 @@ module ActiveMerchant #:nodoc:
       self.live_url = 'https://www.usaepay.com/gate'
       self.test_url = 'https://sandbox.usaepay.com/gate'
 
-      self.supported_cardtypes  = [:visa, :master, :american_express]
+      self.supported_cardtypes  = %i[visa master american_express]
       self.supported_countries  = ['US']
       self.homepage_url         = 'http://www.usaepay.com/'
       self.display_name         = 'USA ePay'
 
       TRANSACTIONS = {
-        :authorization  => 'cc:authonly',
-        :purchase       => 'cc:sale',
-        :capture        => 'cc:capture',
-        :refund         => 'cc:refund',
-        :void           => 'cc:void',
-        :void_release   => 'cc:void:release',
-        :check_purchase => 'check:sale'
+        authorization: 'cc:authonly',
+        purchase: 'cc:sale',
+        capture: 'cc:capture',
+        refund: 'cc:refund',
+        void: 'cc:void',
+        void_release: 'cc:void:release',
+        check_purchase: 'check:sale',
+        store: 'cc:save'
       }
 
       STANDARD_ERROR_CODE_MAPPING = {
@@ -43,14 +44,14 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def authorize(money, credit_card, options = {})
+      def authorize(money, payment, options = {})
         post = {}
 
         add_amount(post, money)
         add_invoice(post, options)
-        add_payment(post, credit_card)
-        unless credit_card.track_data.present?
-          add_address(post, credit_card, options)
+        add_payment(post, payment)
+        unless payment.is_a?(CreditCard) && payment.track_data.present?
+          add_address(post, payment, options)
           add_customer_data(post, options)
         end
         add_split_payments(post, options)
@@ -82,7 +83,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def capture(money, authorization, options = {})
-        post = { :refNum => authorization }
+        post = { refNum: authorization }
 
         add_amount(post, money)
         add_test_mode(post, options)
@@ -90,13 +91,19 @@ module ActiveMerchant #:nodoc:
       end
 
       def refund(money, authorization, options = {})
-        post = { :refNum => authorization }
+        post = { refNum: authorization }
 
         add_amount(post, money)
         add_test_mode(post, options)
         commit(:refund, post)
       end
 
+      def store(payment, options = {})
+        post = {}
+        add_payment(post, payment, options)
+        commit(:store, post)
+      end
+
       def verify(creditcard, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(1, creditcard, options) }
@@ -107,7 +114,7 @@ module ActiveMerchant #:nodoc:
       # Pass `no_release: true` to keep the void from immediately settling
       def void(authorization, options = {})
         command = (options[:no_release] ? :void : :void_release)
-        post = { :refNum => authorization }
+        post = { refNum: authorization }
         add_test_mode(post, options)
         commit(command, post)
       end
@@ -153,13 +160,9 @@ module ActiveMerchant #:nodoc:
           end
         end
 
-        if options.has_key? :customer
-          post[:custid] = options[:customer]
-        end
+        post[:custid] = options[:customer] if options.has_key? :customer
 
-        if options.has_key? :ip
-          post[:ip] = options[:ip]
-        end
+        post[:ip] = options[:ip] if options.has_key? :ip
       end
 
       def add_address(post, payment, options)
@@ -202,12 +205,13 @@ module ActiveMerchant #:nodoc:
         post[:description]  = options[:description]
       end
 
-      def add_payment(post, payment, options={})
+      def add_payment(post, payment, options = {})
         if payment.respond_to?(:routing_number)
           post[:checkformat] = options[:check_format] if options[:check_format]
           if payment.account_type
             account_type = payment.account_type.to_s.capitalize
             raise ArgumentError, 'account_type must be checking or savings' unless %w(Checking Savings).include?(account_type)
+
             post[:accounttype] = account_type
           end
           post[:account] = payment.account_number
@@ -216,6 +220,8 @@ module ActiveMerchant #:nodoc:
         elsif payment.respond_to?(:track_data) && payment.track_data.present?
           post[:magstripe] = payment.track_data
           post[:cardpresent] = true
+        elsif payment.is_a?(String)
+          post[:card]   = payment
         else
           post[:card]   = payment.number
           post[:cvv2]   = payment.verification_value if payment.verification_value?
@@ -232,6 +238,7 @@ module ActiveMerchant #:nodoc:
       # see: http://wiki.usaepay.com/developer/transactionapi#split_payments
       def add_split_payments(post, options)
         return unless options[:split_payments].is_a?(Array)
+
         options[:split_payments].each_with_index do |payment, index|
           prefix = '%02d' % (index + 2)
           post["#{prefix}key"]         = payment[:key]
@@ -245,6 +252,7 @@ module ActiveMerchant #:nodoc:
 
       def add_recurring_fields(post, options)
         return unless options[:recurring_fields].is_a?(Hash)
+
         options[:recurring_fields].each do |key, value|
           if value == true
             value = 'yes'
@@ -252,9 +260,7 @@ module ActiveMerchant #:nodoc:
             next
           end
 
-          if key == :bill_amount
-            value = amount(value)
-          end
+          value = amount(value) if key == :bill_amount
 
           post[key.to_s.delete('_')] = value
         end
@@ -274,6 +280,7 @@ module ActiveMerchant #:nodoc:
       # see: https://wiki.usaepay.com/developer/transactionapi#line_item_details
       def add_line_items(post, options)
         return unless options[:line_items].is_a?(Array)
+
         options[:line_items].each_with_index do |line_item, index|
           %w(product_ref_num sku qty name description taxable tax_rate tax_amount commodity_code discount_rate discount_amount).each do |key|
             post["line#{index}#{key.delete('_')}"] = line_item[key.to_sym] if line_item.has_key?(key.to_sym)
@@ -281,7 +288,7 @@ module ActiveMerchant #:nodoc:
 
           {
             quantity: 'qty',
-            unit: 'um',
+            unit: 'um'
           }.each do |key, umkey|
             post["line#{index}#{umkey}"] = line_item[key.to_sym] if line_item.has_key?(key.to_sym)
           end
@@ -298,21 +305,22 @@ module ActiveMerchant #:nodoc:
         end
 
         {
-          :status           => fields['UMstatus'],
-          :auth_code        => fields['UMauthCode'],
-          :ref_num          => fields['UMrefNum'],
-          :batch            => fields['UMbatch'],
-          :avs_result       => fields['UMavsResult'],
-          :avs_result_code  => fields['UMavsResultCode'],
-          :cvv2_result      => fields['UMcvv2Result'],
-          :cvv2_result_code => fields['UMcvv2ResultCode'],
-          :vpas_result_code => fields['UMvpasResultCode'],
-          :result           => fields['UMresult'],
-          :error            => fields['UMerror'],
-          :error_code       => fields['UMerrorcode'],
-          :acs_url          => fields['UMacsurl'],
-          :payload          => fields['UMpayload']
-        }.delete_if { |k, v| v.nil? }
+          status: fields['UMstatus'],
+          auth_code: fields['UMauthCode'],
+          ref_num: fields['UMrefNum'],
+          card_ref: fields['UMcardRef'],
+          batch: fields['UMbatch'],
+          avs_result: fields['UMavsResult'],
+          avs_result_code: fields['UMavsResultCode'],
+          cvv2_result: fields['UMcvv2Result'],
+          cvv2_result_code: fields['UMcvv2ResultCode'],
+          vpas_result_code: fields['UMvpasResultCode'],
+          result: fields['UMresult'],
+          error: fields['UMerror'],
+          error_code: fields['UMerrorcode'],
+          acs_url: fields['UMacsurl'],
+          payload: fields['UMpayload']
+        }.delete_if { |_k, v| v.nil? }
       end
 
       def commit(action, parameters)
@@ -322,12 +330,11 @@ module ActiveMerchant #:nodoc:
         error_code = nil
         error_code = (STANDARD_ERROR_CODE_MAPPING[response[:error_code]] || STANDARD_ERROR_CODE[:processing_error]) unless approved
         Response.new(approved, message_from(response), response,
-          :test           => test?,
-          :authorization  => response[:ref_num],
-          :cvv_result     => response[:cvv2_result_code],
-          :avs_result     => { :code => response[:avs_result_code] },
-          :error_code     => error_code
-        )
+          test: test?,
+          authorization: authorization_from(action, response),
+          cvv_result: response[:cvv2_result_code],
+          avs_result: { code: response[:avs_result_code] },
+          error_code: error_code)
       end
 
       def message_from(response)
@@ -335,17 +342,22 @@ module ActiveMerchant #:nodoc:
           return 'Success'
         else
           return 'Unspecified error' if response[:error].blank?
+
           return response[:error]
         end
       end
 
+      def authorization_from(action, response)
+        return (action == :store ? response[:card_ref] : response[:ref_num])
+      end
+
       def post_data(action, parameters = {})
         parameters[:command]  = TRANSACTIONS[action]
         parameters[:key]      = @options[:login]
         parameters[:software] = 'Active Merchant'
         parameters[:testmode] = (@options[:test] ? 1 : 0) unless parameters.has_key?(:testmode)
         seed = SecureRandom.hex(32).upcase
-        hash = Digest::SHA1.hexdigest("#{parameters[:command]}:#{@options[:password]}:#{parameters[:amount]}:#{parameters[:invoice]}:#{seed}")
+        hash = Digest::SHA1.hexdigest("#{parameters[:command]}:#{@options[:pin] || @options[:password]}:#{parameters[:amount]}:#{parameters[:invoice]}:#{seed}")
         parameters[:hash] = "s/#{seed}/#{hash}/n"
 
         parameters.collect { |key, value| "UM#{key}=#{CGI.escape(value.to_s)}" }.join('&')

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

@@ -10,24 +10,33 @@ module ActiveMerchant
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
 
       self.homepage_url = 'http://vancopayments.com/'
       self.display_name = 'Vanco Payment Solutions'
 
-      def initialize(options={})
+      SECONDS_PER_DAY = 3600 * 24
+      BUFFER_TIME_IN_SECS = 60 * 3
+
+      def initialize(options = {})
         requires!(options, :user_id, :password, :client_id)
         super
       end
 
-      def purchase(money, payment_method, options={})
-        MultiResponse.run do |r|
-          r.process { login }
-          r.process { commit(purchase_request(money, payment_method, r.params['response_sessionid'], options), :response_transactionref) }
+      def purchase(money, payment_method, options = {})
+        moment_less_than_24_hours_ago = Time.now - SECONDS_PER_DAY - BUFFER_TIME_IN_SECS
+
+        if options[:session_id] && options[:session_id][:created_at] >= moment_less_than_24_hours_ago
+          commit(purchase_request(money, payment_method, options[:session_id][:id], options), :response_transactionref)
+        else
+          MultiResponse.run do |r|
+            r.process { login }
+            r.process { commit(purchase_request(money, payment_method, r.params['response_sessionid'], options), :response_transactionref) }
+          end
         end
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         MultiResponse.run do |r|
           r.process { login }
           r.process { commit(refund_request(money, authorization, r.params['response_sessionid']), :response_creditrequestreceived) }
@@ -108,6 +117,7 @@ module ActiveMerchant
 
       def message_from(succeeded, response)
         return 'Success' if succeeded
+
         response[:error_message]
       end
 
@@ -288,7 +298,6 @@ module ActiveMerchant
           'Content-Type' => 'text/xml'
         }
       end
-
     end
   end
 end

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

@@ -5,8 +5,8 @@ module ActiveMerchant #:nodoc:
     class VerifiGateway < Gateway
       class VerifiPostData < PostData
         # Fields that will be sent even if they are blank
-        self.required_fields = [:amount, :type, :ccnumber, :ccexp, :firstname, :lastname,
-                                :company, :address1, :address2, :city, :state, :zip, :country, :phone]
+        self.required_fields = %i[amount type ccnumber ccexp firstname lastname
+                                  company address1 address2 city state zip country phone]
       end
 
       self.live_url = self.test_url = 'https://secure.verifi.com/gw/api/transact.php'
@@ -50,16 +50,16 @@ module ActiveMerchant #:nodoc:
       SUCCESS = 1
 
       TRANSACTIONS = {
-        :authorization => 'auth',
-        :purchase => 'sale',
-        :capture => 'capture',
-        :void => 'void',
-        :credit => 'credit',
-        :refund => 'refund'
+        authorization: 'auth',
+        purchase: 'sale',
+        capture: 'capture',
+        void: 'void',
+        credit: 'credit',
+        refund: 'refund'
       }
 
       self.supported_countries = ['US']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
       self.homepage_url = 'http://www.verifi.com/'
       self.display_name = 'Verifi'
 
@@ -195,11 +195,10 @@ module ActiveMerchant #:nodoc:
         response = parse(ssl_post(self.live_url, post_data(trx_type, post)))
 
         Response.new(response[:response].to_i == SUCCESS, message_from(response), response,
-          :test => test?,
-          :authorization => response[:transactionid],
-          :avs_result => { :code => response[:avsresponse] },
-          :cvv_result => response[:cvvresponse]
-        )
+          test: test?,
+          authorization: response[:transactionid],
+          avs_result: { code: response[:avsresponse] },
+          cvv_result: response[:cvvresponse])
       end
 
       def message_from(response)

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

@@ -8,13 +8,13 @@ module ActiveMerchant #:nodoc:
       self.delimiter = "\r\n"
 
       self.actions = {
-        :purchase => 'SALE',
-        :credit => 'CREDIT'
+        purchase: 'SALE',
+        credit: 'CREDIT'
       }
 
       APPROVED = '0'
 
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
       self.supported_countries = ['US']
       self.display_name = 'ViaKLIX'
       self.homepage_url = 'http://viaklix.com'
@@ -49,9 +49,7 @@ module ActiveMerchant #:nodoc:
       # 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
+        raise ArgumentError, 'Reference credits are not supported. Please supply the original credit card' if creditcard.is_a?(String)
 
         form = {}
         add_invoice(form, options)
@@ -109,9 +107,7 @@ module ActiveMerchant #:nodoc:
         form[:card_number] = creditcard.number
         form[:exp_date] = expdate(creditcard)
 
-        if creditcard.verification_value?
-          add_verification_value(form, creditcard)
-        end
+        add_verification_value(form, creditcard) if creditcard.verification_value?
 
         form[:first_name] = creditcard.first_name.to_s.slice(0, 20)
         form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
@@ -141,11 +137,10 @@ module ActiveMerchant #:nodoc:
         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?,
-          :authorization => authorization_from(response),
-          :avs_result => { :code => response['avs_response'] },
-          :cvv_result => response['cvv2_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)

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

@@ -8,24 +8,24 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://devapi.vnforapps.com/api.tokenization/api/v2/merchant'
       self.live_url = 'https://api.vnforapps.com/api.tokenization/api/v2/merchant'
 
-      self.supported_countries = ['US', 'PE']
+      self.supported_countries = %w[US PE]
       self.default_currency = 'PEN'
       self.money_format = :dollars
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :access_key_id, :secret_access_key, :merchant_id)
         super
       end
 
-      def purchase(amount, payment_method, options={})
+      def purchase(amount, payment_method, options = {})
         MultiResponse.run() do |r|
           r.process { authorize(amount, payment_method, options) }
           r.process { capture(amount, r.authorization, options) }
         end
       end
 
-      def authorize(amount, payment_method, options={})
+      def authorize(amount, payment_method, options = {})
         params = {}
 
         add_invoice(params, amount, options)
@@ -37,20 +37,20 @@ module ActiveMerchant #:nodoc:
         commit('authorize', params, options)
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         params = {}
         options[:id_unico] = split_authorization(authorization)[1]
         add_auth_order_id(params, authorization, options)
         commit('deposit', params, options)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         params = {}
         add_auth_order_id(params, authorization, options)
         commit('void', params, options)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         params = {}
         params[:amount] = amount(amount) if amount
         add_auth_order_id(params, authorization, options)
@@ -65,7 +65,7 @@ module ActiveMerchant #:nodoc:
         commit('refund', params, options)
       end
 
-      def verify(credit_card, options={})
+      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) }
@@ -85,20 +85,20 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      CURRENCY_CODES = Hash.new { |h, k| raise ArgumentError.new("Unsupported currency: #{k}") }
+      CURRENCY_CODES = Hash.new { |_h, k| raise ArgumentError.new("Unsupported currency: #{k}") }
       CURRENCY_CODES['USD'] = 840
       CURRENCY_CODES['PEN'] = 604
 
       def add_invoice(params, money, options)
-        # Visanet Peru expects a 9-digit numeric purchaseNumber
-        params[:purchaseNumber] = (SecureRandom.random_number(900_000_000) + 100_000_000).to_s
+        # Visanet Peru expects a 12-digit alphanumeric purchaseNumber
+        params[:purchaseNumber] = generate_purchase_number_stamp
         params[:externalTransactionId] = options[:order_id]
         params[:amount] = amount(money)
         params[:currencyId] = CURRENCY_CODES[options[:currency] || currency(money)]
       end
 
       def add_auth_order_id(params, authorization, options)
-        purchase_number, _ = split_authorization(authorization)
+        purchase_number, = split_authorization(authorization)
         params[:purchaseNumber] = purchase_number
         params[:externalTransactionId] = options[:order_id]
       end
@@ -142,7 +142,11 @@ module ActiveMerchant #:nodoc:
         authorization.split('|')
       end
 
-      def commit(action, params, options={})
+      def generate_purchase_number_stamp
+        Time.now.to_f.to_s.delete('.')[1..10] + rand(99).to_s
+      end
+
+      def commit(action, params, options = {})
         raw_response = ssl_request(method(action), url(action, params, options), params.to_json, headers)
         response = parse(raw_response)
       rescue ResponseError => e
@@ -155,9 +159,9 @@ module ActiveMerchant #:nodoc:
           success_from(response),
           message_from(response, options, action),
           response,
-          :test => test?,
-          :authorization => authorization_from(params, response, options),
-          :error_code => response['errorCode']
+          test: test?,
+          authorization: authorization_from(params, response, options),
+          error_code: response['errorCode']
         )
       end
 
@@ -168,7 +172,7 @@ module ActiveMerchant #:nodoc:
         }
       end
 
-      def url(action, params, options={})
+      def url(action, params, options = {})
         if action == 'authorize'
           "#{base_url}/#{@options[:merchant_id]}"
         elsif action == 'refund'
@@ -213,6 +217,7 @@ module ActiveMerchant #:nodoc:
 
       def action_code_description(response)
         return nil unless response['data']
+
         response['data']['DSC_COD_ACCION']
       end
 
@@ -229,9 +234,9 @@ module ActiveMerchant #:nodoc:
           false,
           message_from(response, options, action),
           response,
-          :test => test?,
-          :authorization => response['transactionUUID'],
-          :error_code => response['errorCode']
+          test: test?,
+          authorization: response['transactionUUID'],
+          error_code: response['errorCode']
         )
       end