activemerchant 1.45.0 → 1.126.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
@@ -92,7 +91,7 @@ module ActiveMerchant #:nodoc:
         end
 
         if shipping_address = options[:shipping_address]
-          first_name, last_name = parse_first_and_last_name(shipping_address[:name])
+          first_name, last_name = split_names(shipping_address[:name])
           form[:ship_to_first_name]     = first_name.to_s.slice(0, 20)
           form[:ship_to_last_name]      = last_name.to_s.slice(0, 30)
           form[:ship_to_address]        = shipping_address[:address1].to_s.slice(0, 30)
@@ -104,21 +103,11 @@ module ActiveMerchant #:nodoc:
         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 ]
-      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
+        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)
@@ -145,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)
@@ -166,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

@@ -0,0 +1,250 @@
+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.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 = %w[US PE]
+      self.default_currency = 'PEN'
+      self.money_format = :dollars
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      def initialize(options = {})
+        requires!(options, :access_key_id, :secret_access_key, :merchant_id)
+        super
+      end
+
+      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 = {})
+        params = {}
+
+        add_invoice(params, amount, options)
+        add_payment_method(params, payment_method)
+        add_antifraud_data(params, options)
+        params[:email] = options[:email] || 'unknown@email.com'
+        params[:createAlias] = false
+
+        commit('authorize', params, options)
+      end
+
+      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 = {})
+        params = {}
+        add_auth_order_id(params, authorization, options)
+        commit('void', params, options)
+      end
+
+      def refund(amount, authorization, options = {})
+        params = {}
+        params[:amount] = amount(amount) if amount
+        add_auth_order_id(params, authorization, options)
+        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 = {})
+        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((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((\"cardNumber\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cvv2Code\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      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 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)
+        params[:purchaseNumber] = purchase_number
+        params[:externalTransactionId] = options[:order_id]
+      end
+
+      def add_payment_method(params, payment_method)
+        params[:firstName] = payment_method.first_name
+        params[:lastName] = payment_method.last_name
+        params[:cardNumber] = payment_method.number
+        params[:cvv2Code] = payment_method.verification_value
+        params[:expirationYear] = format(payment_method.year, :four_digits)
+        params[:expirationMonth] = format(payment_method.month, :two_digits)
+      end
+
+      def add_antifraud_data(params, options)
+        antifraud = {}
+
+        if billing_address = options[:billing_address] || options[:address]
+          antifraud[:billTo_street1] = billing_address[:address1]
+          antifraud[:billTo_city] = billing_address[:city]
+          antifraud[:billTo_state] = billing_address[:state]
+          antifraud[:billTo_country] = billing_address[:country]
+          antifraud[:billTo_postalCode] = billing_address[:zip]
+        end
+
+        antifraud[:deviceFingerprintId] = options[:device_fingerprint_id] || SecureRandom.hex(16)
+        antifraud[:merchantDefineData] = options[:merchant_define_data] if options[:merchant_define_data]
+
+        params[:antifraud] = antifraud
+      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.round(2) * 100).to_i.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'
+        }
+      end
+
+      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)
+        %w(authorize refund).include?(action) ? :post : :put
+      end
+
+      def authorization_from(params, response, options)
+        id_unico = response['data']['ID_UNICO'] || options[:id_unico]
+        "#{params[:purchaseNumber]}|#{id_unico}"
+      end
+
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        response['errorCode'] == 0
+      end
+
+      def message_from(response, options, action)
+        message_from_messages(
+          response['errorMessage'],
+          action_code_description(response),
+          options[:error_message]
+        )
+      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 += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+    end
+  end
+end