activemerchant 1.79.2 → 1.129.0

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

@@ -5,61 +5,61 @@ 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'
 
       RESPONSE_CODE_MESSAGES = {
-        "100" => "Transaction was Approved",
-        "200" => "Transaction was Declined by Processor",
-        "201" => "Do Not Honor",
-        "202" => "Insufficient Funds",
-        "203" => "Over Limit",
-        "204" => "Transaction not allowed",
-        "220" => "Incorrect payment Data",
-        "221" => "No Such Card Issuer",
-        "222" => "No Card Number on file with Issuer",
-        "223" => "Expired Card",
-        "224" => "Invalid Expiration Date",
-        "225" => "Invalid Card Security Code",
-        "240" => "Call Issuer for Further Information",
-        "250" => "Pick Up Card",
-        "251" => "Lost Card",
-        "252" => "Stolen Card",
-        "253" => "Fraudulent Card",
-        "260" => "Declined With further Instructions Available (see response text)",
-        "261" => "Declined - Stop All Recurring Payments",
-        "262" => "Declined - Stop this Recurring Program",
-        "263" => "Declined - Update Cardholder Data Available",
-        "264" => "Declined - Retry in a few days",
-        "300" => "Transaction was Rejected by Gateway",
-        "400" => "Transaction Error Returned by Processor",
-        "410" => "Invalid Merchant Configuration",
-        "411" => "Merchant Account is Inactive",
-        "420" => "Communication Error",
-        "421" => "Communication Error with Issuer",
-        "430" => "Duplicate Transaction at Processor",
-        "440" => "Processor Format Error",
-        "441" => "Invalid Transaction Information",
-        "460" => "Processor Feature Not Available",
-        "461" => "Unsupported Card Type"
+        '100' => 'Transaction was Approved',
+        '200' => 'Transaction was Declined by Processor',
+        '201' => 'Do Not Honor',
+        '202' => 'Insufficient Funds',
+        '203' => 'Over Limit',
+        '204' => 'Transaction not allowed',
+        '220' => 'Incorrect payment Data',
+        '221' => 'No Such Card Issuer',
+        '222' => 'No Card Number on file with Issuer',
+        '223' => 'Expired Card',
+        '224' => 'Invalid Expiration Date',
+        '225' => 'Invalid Card Security Code',
+        '240' => 'Call Issuer for Further Information',
+        '250' => 'Pick Up Card',
+        '251' => 'Lost Card',
+        '252' => 'Stolen Card',
+        '253' => 'Fraudulent Card',
+        '260' => 'Declined With further Instructions Available (see response text)',
+        '261' => 'Declined - Stop All Recurring Payments',
+        '262' => 'Declined - Stop this Recurring Program',
+        '263' => 'Declined - Update Cardholder Data Available',
+        '264' => 'Declined - Retry in a few days',
+        '300' => 'Transaction was Rejected by Gateway',
+        '400' => 'Transaction Error Returned by Processor',
+        '410' => 'Invalid Merchant Configuration',
+        '411' => 'Merchant Account is Inactive',
+        '420' => 'Communication Error',
+        '421' => 'Communication Error with Issuer',
+        '430' => 'Duplicate Transaction at Processor',
+        '440' => 'Processor Format Error',
+        '441' => 'Invalid Transaction Information',
+        '460' => 'Processor Feature Not Available',
+        '461' => 'Unsupported Card Type'
       }
 
       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'
 
@@ -180,10 +180,10 @@ module ActiveMerchant #:nodoc:
         # MD5(username|password|orderid|amount|time)
         now = Time.now.to_i.to_s
         md5 = Digest::MD5.new
-        md5 << @options[:login].to_s + "|"
-        md5 << @options[:password].to_s + "|"
-        md5 << options[:order_id].to_s + "|"
-        md5 << amount(money).to_s + "|"
+        md5 << @options[:login].to_s + '|'
+        md5 << @options[:password].to_s + '|'
+        md5 << options[:order_id].to_s + '|'
+        md5 << amount(money).to_s + '|'
         md5 << now
         post[:key]  = md5.hexdigest
         post[:time] = now
@@ -192,18 +192,17 @@ module ActiveMerchant #:nodoc:
       def commit(trx_type, money, post)
         post[:amount] = amount(money)
 
-        response = parse( ssl_post(self.live_url, post_data(trx_type, post)) )
+        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)
-        response[:response_code_message] ? response[:response_code_message] : ""
+        response[:response_code_message] || ''
       end
 
       def parse(body)

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)
@@ -63,6 +61,7 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+
       def add_test_mode(form, options)
         form[:test_mode] = 'TRUE' if options[:test_mode]
       end
@@ -72,12 +71,12 @@ module ActiveMerchant #:nodoc:
         form[:customer_code] = options[:customer].to_s.slice(0, 10) unless options[:customer].blank?
       end
 
-      def add_invoice(form,options)
+      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)
+      def add_address(form, options)
         billing_address = options[:billing_address] || options[:address]
 
         if billing_address
@@ -108,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)
@@ -137,14 +134,13 @@ module ActiveMerchant #:nodoc:
         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 = 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)
@@ -158,16 +154,16 @@ module ActiveMerchant #:nodoc:
       def post_data(parameters)
         result = preamble
         result.merge!(parameters)
-        result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       # Parse the response message
       def parse(msg)
         resp = {}
-        msg.split(self.delimiter).collect{|li|
-            key, value = li.split("=")
-            resp[key.strip.gsub(/^ssl_/, '')] = value.to_s.strip
-          }
+        msg.split(self.delimiter).collect { |li|
+          key, value = li.split('=')
+          resp[key.strip.gsub(/^ssl_/, '')] = value.to_s.strip
+        }
         resp
       end
     end

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

@@ -2,30 +2,30 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class VisanetPeruGateway < Gateway
       include Empty
-      self.display_name = "VisaNet Peru Gateway"
-      self.homepage_url = "http://www.visanet.com.pe"
+      self.display_name = 'VisaNet Peru Gateway'
+      self.homepage_url = 'http://www.visanet.com.pe'
 
-      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.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.default_currency = "PEN"
+      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(r.authorization, 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)
@@ -34,28 +34,38 @@ module ActiveMerchant #:nodoc:
         params[:email] = options[:email] || 'unknown@email.com'
         params[:createAlias] = false
 
-        commit("authorize", params)
+        commit('authorize', params, options)
       end
 
-      def capture(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)
+        commit('deposit', params, options)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         params = {}
         add_auth_order_id(params, authorization, options)
-        commit("void", params)
+        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)
-        commit("cancelDeposit", params)
+        response = commit('cancelDeposit', params, options)
+        return response if response.success? || split_authorization(authorization).length == 1 || !options[:force_full_refund_if_unsettled]
+
+        # Attempt RefundSingleTransaction if unsettled (and stash the original
+        # response message so it will be included it in the follow-up response
+        # message)
+        options[:error_message] = response.message
+        prepare_refund_data(params, authorization, options)
+        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) }
@@ -75,20 +85,21 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
-      CURRENCY_CODES["USD"] = 840
-      CURRENCY_CODES["PEN"] = 604
+      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)
-        params[:purchaseNumber] = authorization
+        purchase_number, = split_authorization(authorization)
+        params[:purchaseNumber] = purchase_number
         params[:externalTransactionId] = options[:order_id]
       end
 
@@ -118,48 +129,66 @@ module ActiveMerchant #:nodoc:
         params[:antifraud] = antifraud
       end
 
-      def commit(action, params)
-        begin
-          raw_response = ssl_request(method(action), url(action, params), params.to_json, headers)
-          response = parse(raw_response)
-        rescue ResponseError => e
-          raw_response = e.response.body
-          response_error(raw_response)
-        rescue JSON::ParserError
-          unparsable_response(raw_response)
-        else
-          Response.new(
-            success_from(response),
-            message_from(response),
-            response,
-            :test => test?,
-            :authorization => authorization_from(params),
-            :error_code => response["errorCode"]
-          )
-        end
+      def prepare_refund_data(params, authorization, options)
+        params.delete(:purchaseNumber)
+        params[:externalReferenceId] = params.delete(:externalTransactionId)
+        _, transaction_id = split_authorization(authorization)
+
+        options.update(transaction_id: transaction_id)
+        params[:ruc] = options[:ruc]
+      end
+
+      def split_authorization(authorization)
+        authorization.split('|')
+      end
+
+      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
+        raw_response = e.response.body
+        response_error(raw_response, options, action)
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      else
+        Response.new(
+          success_from(response),
+          message_from(response, options, action),
+          response,
+          test: test?,
+          authorization: authorization_from(params, response, options),
+          error_code: response['errorCode']
+        )
       end
 
       def headers
         {
-          "Authorization" => "Basic " + Base64.strict_encode64("#{@options[:access_key_id]}:#{@options[:secret_access_key]}").strip,
-          "Content-Type"  => "application/json"
+          'Authorization' => 'Basic ' + Base64.strict_encode64("#{@options[:access_key_id]}:#{@options[:secret_access_key]}").strip,
+          'Content-Type'  => 'application/json'
         }
       end
 
-      def url(action, params)
-        if (action == "authorize")
+      def url(action, params, options = {})
+        if action == 'authorize'
           "#{base_url}/#{@options[:merchant_id]}"
+        elsif action == 'refund'
+          "#{base_url}/#{@options[:merchant_id]}/#{action}/#{options[:transaction_id]}"
         else
           "#{base_url}/#{@options[:merchant_id]}/#{action}/#{params[:purchaseNumber]}"
         end
       end
 
       def method(action)
-        (action == "authorize") ? :post : :put
+        %w(authorize refund).include?(action) ? :post : :put
       end
 
-      def authorization_from(params)
-        params[:purchaseNumber]
+      def authorization_from(params, response, options)
+        id_unico = response['data']['ID_UNICO'] || options[:id_unico]
+        "#{params[:purchaseNumber]}|#{id_unico}"
       end
 
       def base_url
@@ -171,36 +200,48 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response)
-        response["errorCode"] == 0
+        response['errorCode'] == 0
       end
 
-      def message_from(response)
-        if empty?(response["errorMessage"]) || response["errorMessage"] == "[ ]"
-          response["data"]["DSC_COD_ACCION"]
-        else
-          response["errorMessage"]
-        end
+      def message_from(response, options, action)
+        message_from_messages(
+          response['errorMessage'],
+          action_code_description(response),
+          options[:error_message]
+        )
       end
 
-      def response_error(raw_response)
-        begin
-          response = parse(raw_response)
-        rescue JSON::ParserError
-          unparsable_response(raw_response)
-        else
-          return Response.new(
-            false,
-            message_from(response),
-            response,
-            :test => test?,
-            :authorization => response["transactionUUID"],
-            :error_code => response["errorCode"]
-          )
-        end
+      def message_from_messages(*args)
+        args.reject { |m| error_message_empty?(m) }.join(' | ')
+      end
+
+      def action_code_description(response)
+        return nil unless response['data']
+
+        response['data']['DSC_COD_ACCION']
+      end
+
+      def error_message_empty?(error_message)
+        empty?(error_message) || error_message == '[ ]'
+      end
+
+      def response_error(raw_response, options, action)
+        response = parse(raw_response)
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      else
+        return Response.new(
+          false,
+          message_from(response, options, action),
+          response,
+          test: test?,
+          authorization: response['transactionUUID'],
+          error_code: response['errorCode']
+        )
       end
 
       def unparsable_response(raw_response)
-        message = "Invalid JSON response received from VisanetPeruGateway. Please contact VisanetPeruGateway if you continue to receive this message."
+        message = 'Invalid JSON response received from VisanetPeruGateway. Please contact VisanetPeruGateway if you continue to receive this message.'
         message += " (The raw response returned by the API was #{raw_response.inspect})"
         return Response.new(false, message)
       end