activemerchant 1.42.6 → 1.90.0

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

@@ -5,46 +5,46 @@ 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 = [: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
@@ -86,7 +86,7 @@ module ActiveMerchant #:nodoc:
 
       def credit(money, credit_card_or_authorization, options = {})
         if credit_card_or_authorization.is_a?(String)
-          deprecated CREDIT_DEPRECATION_MESSAGE
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
           refund(money, credit_card_or_authorization, options)
         else
           sale_authorization_or_credit_template(:credit, money, credit_card_or_authorization, options)
@@ -125,13 +125,6 @@ module ActiveMerchant #:nodoc:
         post[:cvv]       = credit_card.verification_value
       end
 
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-
       def add_addresses(post, options)
         if billing_address = options[:billing_address] || options[:address]
           post[:company]    = billing_address[:company]
@@ -187,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
@@ -199,7 +192,7 @@ 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?,
@@ -210,7 +203,7 @@ module ActiveMerchant #:nodoc:
       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

@@ -50,7 +50,7 @@ module ActiveMerchant #:nodoc:
       # 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"
+          raise ArgumentError, 'Reference credits are not supported. Please supply the original credit card'
         end
 
         form = {}
@@ -63,6 +63,7 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+
       def add_test_mode(form, options)
         form[:test_mode] = 'TRUE' if options[:test_mode]
       end
@@ -72,12 +73,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 +93,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,14 +105,6 @@ 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)
@@ -145,7 +138,7 @@ 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?,
@@ -166,22 +159,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("&")
-      end
-
-      def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-        "#{month}#{year[2..3]}"
+        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,233 @@
+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 = ['US', 'PE']
+      self.default_currency = 'PEN'
+      self.money_format = :dollars
+      self.supported_cardtypes = [: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(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(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
+        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 9-digit numeric purchaseNumber
+        params[:purchaseNumber] = (SecureRandom.random_number(900_000_000) + 100_000_000).to_s
+        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 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)
+        if empty?(response['errorMessage']) || response['errorMessage'] == '[ ]'
+          action == 'refund' ? "#{response['data']['DSC_COD_ACCION']}, #{options[:error_message]}" : response['data']['DSC_COD_ACCION']
+        elsif action == 'refund'
+          message = "#{response['errorMessage']}, #{options[:error_message]}"
+          options[:error_message] = response['errorMessage']
+          message
+        else
+          response['errorMessage']
+        end
+      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

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

@@ -14,14 +14,15 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'WebPay'
 
       def capture(money, authorization, options = {})
-        post = {:amount => localized_amount(money)}
+        post = {}
+        add_amount(post, money, options)
         add_application_fee(post, options)
         commit(:post, "charges/#{CGI.escape(authorization)}/capture", post)
       end
 
       def refund(money, identification, options = {})
-        post = {:amount => localized_amount(money)}
-
+        post = {}
+        add_amount(post, money, options)
         MultiResponse.run do |r|
           r.process { commit(:post, "charges/#{CGI.escape(identification)}/refund", post, options) }
 
@@ -36,15 +37,6 @@ module ActiveMerchant #:nodoc:
         raise NotImplementedError.new
       end
 
-      def localized_amount(money, currency = self.default_currency)
-        non_fractional_currency?(currency) ? (amount(money).to_f / 100).floor : amount(money)
-      end
-
-      def add_amount(post, money, options)
-        post[:currency] = (options[:currency] || currency(money)).downcase
-        post[:amount] = localized_amount(money, post[:currency].upcase)
-      end
-
       def add_customer(post, creditcard, options)
         post[:customer] = options[:customer] if options[:customer] && !creditcard.respond_to?(:number)
       end
@@ -59,39 +51,45 @@ module ActiveMerchant #:nodoc:
           MultiResponse.run(:first) do |r|
             r.process { commit(:post, "customers/#{CGI.escape(options[:customer])}/", post, options) }
 
-            return r unless options[:set_default] and r.success? and !r.params["id"].blank?
+            return r unless options[:set_default] and r.success? and !r.params['id'].blank?
 
-            r.process { update_customer(options[:customer], :default_card => r.params["id"]) }
+            r.process { update_customer(options[:customer], :default_card => r.params['id']) }
           end
         else
           commit(:post, 'customers', post, options)
         end
       end
 
+      def update(customer_id, creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard, options)
+        commit(:post, "customers/#{CGI.escape(customer_id)}", post, options)
+      end
+
+      private
+
+      def create_post_for_auth_or_purchase(money, creditcard, options)
+        stripe_post = super
+        stripe_post[:description] ||= stripe_post.delete(:metadata).try(:[], :email)
+        stripe_post
+      end
+
       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
+          'error' => {
+            'message' => msg
           }
         }
       end
 
       def headers(options = {})
-        @@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'
-        })
-
         {
-          "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" => {:ip => options[:ip]}.to_json
+          'Authorization' => 'Basic ' + Base64.encode64(@api_key.to_s + ':').strip,
+          'User-Agent' => "Webpay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'X-Webpay-Client-User-Agent' => user_agent,
+          'X-Webpay-Client-User-Metadata' => {:ip => options[:ip]}.to_json
         }
       end
     end