activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,277 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MercadoPagoGateway < Gateway
+      self.live_url = self.test_url = 'https://api.mercadopago.com/v1'
+
+      self.supported_countries = ['AR', 'BR', 'CL', 'CO', 'MX', 'PE', 'UY']
+      self.supported_cardtypes = [:visa, :master, :american_express]
+
+      self.homepage_url = 'https://www.mercadopago.com/'
+      self.display_name = 'Mercado Pago'
+      self.money_format = :dollars
+
+      def initialize(options={})
+        requires!(options, :access_token)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        MultiResponse.run do |r|
+          r.process { commit('tokenize', 'card_tokens', card_token_request(money, payment, options)) }
+          options[:card_token] = r.authorization.split('|').first
+          r.process { commit('purchase', 'payments', purchase_request(money, payment, options)) }
+        end
+      end
+
+      def authorize(money, payment, options={})
+        MultiResponse.run do |r|
+          r.process { commit('tokenize', 'card_tokens', card_token_request(money, payment, options)) }
+          options[:card_token] = r.authorization.split('|').first
+          r.process { commit('authorize', 'payments', authorize_request(money, payment, options)) }
+        end
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        authorization, _ = authorization.split('|')
+        post[:capture] = true
+        post[:transaction_amount] = amount(money).to_f
+        commit('capture', "payments/#{authorization}", post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        authorization, original_amount = authorization.split('|')
+        post[:amount] = amount(money).to_f if original_amount && original_amount.to_f > amount(money).to_f
+        commit('refund', "payments/#{authorization}/refunds", post)
+      end
+
+      def void(authorization, options={})
+        authorization, _ = authorization.split('|')
+        post = { status: 'cancelled' }
+        commit('void', "payments/#{authorization}", post)
+      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((access_token=).*?([^\s]+)), '\1[FILTERED]').
+          gsub(%r((\"card_number\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"security_code\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def card_token_request(money, payment, options = {})
+        post = {}
+        post[:card_number] = payment.number
+        post[:security_code] = payment.verification_value
+        post[:expiration_month] = payment.month
+        post[:expiration_year] = payment.year
+        post[:cardholder] = {
+          name: payment.name,
+          identification: {
+            type: options[:cardholder_identification_type],
+            number: options[:cardholder_identification_number]
+          }
+        }
+        post
+      end
+
+      def purchase_request(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, options)
+        add_additional_data(post, options)
+        add_customer_data(post, payment, options)
+        add_address(post, options)
+        add_processing_mode(post, options)
+        post[:binary_mode] = (options[:binary_mode].nil? ? true : options[:binary_mode])
+        post
+      end
+
+      def authorize_request(money, payment, options = {})
+        post = purchase_request(money, payment, options)
+        post[:capture] = false
+        post
+      end
+
+      def add_processing_mode(post, options)
+        return unless options[:processing_mode]
+        post[:processing_mode] = options[:processing_mode]
+        post[:merchant_account_id] = options[:merchant_account_id] if options[:merchant_account_id]
+        add_merchant_services(post, options)
+      end
+
+      def add_merchant_services(post, options)
+        return unless options[:fraud_scoring] || options[:fraud_manual_review]
+        merchant_services = {}
+        merchant_services[:fraud_scoring] = options[:fraud_scoring] if options[:fraud_scoring]
+        merchant_services[:fraud_manual_review] = options[:fraud_manual_review] if options[:fraud_manual_review]
+        post[:merchant_services] = merchant_services
+      end
+
+      def add_additional_data(post, options)
+        post[:sponsor_id] = options[:sponsor_id]
+        post[:device_id] = options[:device_id] if options[:device_id]
+        post[:additional_info] = {
+          ip_address: options[:ip_address]
+        }.merge(options[:additional_info] || {})
+
+        add_address(post, options)
+        add_shipping_address(post, options)
+      end
+
+      def add_customer_data(post, payment, options)
+        post[:payer] = {
+          email: options[:email],
+          first_name: payment.first_name,
+          last_name: payment.last_name
+        }
+      end
+
+      def add_address(post, options)
+        if address = (options[:billing_address] || options[:address])
+
+          post[:additional_info].merge!({
+            payer: {
+              address: {
+                zip_code: address[:zip],
+                street_name: "#{address[:address1]} #{address[:address2]}"
+              }
+            }
+          })
+        end
+      end
+
+      def add_shipping_address(post, options)
+        if address = options[:shipping_address]
+
+          post[:additional_info].merge!({
+            shipments: {
+              receiver_address: {
+                zip_code: address[:zip],
+                street_name: "#{address[:address1]} #{address[:address2]}"
+              }
+            }
+          })
+        end
+      end
+
+      def split_street_address(address1)
+        street_number = address1.split(' ').first
+
+        if street_name = address1.split(' ')[1..-1]
+          street_name = street_name.join(' ')
+        else
+          nil
+        end
+
+        [street_number, street_name]
+      end
+
+      def add_invoice(post, money, options)
+        post[:transaction_amount] = amount(money).to_f
+        post[:description] = options[:description]
+        post[:installments] = options[:installments] ? options[:installments].to_i : 1
+        post[:statement_descriptor] = options[:statement_descriptor] if options[:statement_descriptor]
+        post[:external_reference] = options[:order_id] || SecureRandom.hex(16)
+      end
+
+      def add_payment(post, options)
+        post[:token] = options[:card_token]
+        post[:issuer_id] = options[:issuer_id] if options[:issuer_id]
+        post[:payment_method_id] = options[:payment_method_id] if options[:payment_method_id]
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      rescue JSON::ParserError
+        {
+          'status' => 'error',
+          'status_detail' => 'json_parse_error',
+          'message' => "A non-JSON response was received from Mercado Pago where one was expected. The raw response was:\n\n#{body}"
+        }
+      end
+
+      def commit(action, path, parameters)
+        if ['capture', 'void'].include?(action)
+          response = parse(ssl_request(:put, url(path), post_data(parameters), headers))
+        else
+          response = parse(ssl_post(url(path), post_data(parameters), headers(parameters)))
+        end
+
+        Response.new(
+          success_from(action, response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, parameters),
+          test: test?,
+          error_code: error_code_from(action, response)
+        )
+      end
+
+      def success_from(action, response)
+        if action == 'refund'
+          response['status'] != 404 && response['error'].nil?
+        else
+          ['active', 'approved', 'authorized', 'cancelled', 'in_process'].include?(response['status'])
+        end
+      end
+
+      def message_from(response)
+        (response['status_detail']) || (response['message'])
+      end
+
+      def authorization_from(response, params)
+        [response['id'], params[:transaction_amount]].join('|')
+      end
+
+      def post_data(parameters = {})
+        parameters.clone.tap { |p| p.delete(:device_id) }.to_json
+      end
+
+      def error_code_from(action, response)
+        unless success_from(action, response)
+          if cause = response['cause']
+            cause.empty? ? nil : cause.first['code']
+          else
+            response['status']
+          end
+        end
+      end
+
+      def url(action)
+        full_url = (test? ? test_url : live_url)
+        full_url + "/#{action}?access_token=#{CGI.escape(@options[:access_token])}"
+      end
+
+      def headers(options = {})
+        headers = {
+          'Content-Type' => 'application/json'
+        }
+        headers['X-Device-Session-ID'] = options[:device_id] if options[:device_id]
+        headers
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200..499
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,8 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class MerchantESolutionsGateway < Gateway
+      include Empty
+
       self.test_url = 'https://cert.merchante-solutions.com/mes-api/tridentApi'
       self.live_url = 'https://api.merchante-solutions.com/mes-api/tridentApi'
 
@@ -28,6 +30,7 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, options)
         add_payment_source(post, creditcard_or_card_id, options)
         add_address(post, options)
+        add_3dsecure_params(post, options)
         commit('P', money, post)
       end
 
@@ -38,6 +41,7 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, options)
         add_payment_source(post, creditcard_or_card_id, options)
         add_address(post, options)
+        add_3dsecure_params(post, options)
         commit('D', money, post)
       end
 
@@ -45,6 +49,8 @@ module ActiveMerchant #:nodoc:
         post ={}
         post[:transaction_id] = transaction_id
         post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        add_invoice(post, options)
+        add_3dsecure_params(post, options)
         commit('S', money, post)
       end
 
@@ -88,6 +94,17 @@ module ActiveMerchant #:nodoc:
         commit('V', nil, options.merge(post))
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?profile_key=)\w*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?card_number=)\d*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?cvv2=)\d*(&?)), '\1[FILTERED]\2')
+      end
+
       private
 
       def add_address(post, options)
@@ -99,7 +116,8 @@ module ActiveMerchant #:nodoc:
 
       def add_invoice(post, options)
         if options.has_key? :order_id
-          post[:invoice_number] = options[:order_id].to_s.gsub(/[^\w.]/, '')
+          order_id = options[:order_id].to_s.gsub(/[^\w.]/, '')
+          post[:invoice_number] = truncate(order_id, 17)
         end
       end
 
@@ -120,10 +138,17 @@ module ActiveMerchant #:nodoc:
         post[:card_exp_date]  = expdate(creditcard)
       end
 
+      def add_3dsecure_params(post, options)
+        post[:xid] = options[:xid] unless empty?(options[:xid])
+        post[:cavv] = options[:cavv] unless empty?(options[:cavv])
+        post[:ucaf_collection_ind] = options[:ucaf_collection_ind] unless empty?(options[:ucaf_collection_ind])
+        post[:ucaf_auth_data] = options[:ucaf_auth_data] unless empty?(options[:ucaf_auth_data])
+      end
+
       def parse(body)
         results = {}
         body.split(/&/).each do |pair|
-          key,val = pair.split(/=/)
+          key, val = pair.split(/=/)
           results[key] = val
         end
         results
@@ -133,32 +158,25 @@ module ActiveMerchant #:nodoc:
         url = test? ? self.test_url : self.live_url
         parameters[:transaction_amount]  = amount(money) if money unless action == 'V'
 
-
         response = begin
-          parse( ssl_post(url, post_data(action,parameters)) )
+          parse(ssl_post(url, post_data(action, parameters)))
         rescue ActiveMerchant::ResponseError => e
-          { "error_code" => "404",  "auth_response_text" => e.to_s }
+          { 'error_code' => '404',  'auth_response_text' => e.to_s }
         end
 
-        Response.new(response["error_code"] == "000", message_from(response), response,
-          :authorization => response["transaction_id"],
+        Response.new(response['error_code'] == '000', message_from(response), response,
+          :authorization => response['transaction_id'],
           :test => test?,
-          :cvv_result => response["cvv2_result"],
-          :avs_result => { :code => response["avs_result"] }
+          :cvv_result => response['cvv2_result'],
+          :avs_result => { :code => response['avs_result'] }
         )
       end
 
-      def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-        "#{month}#{year[-2..-1]}"
-      end
-
       def message_from(response)
-        if response["error_code"] == "000"
-          "This transaction has been approved"
+        if response['error_code'] == '000'
+          'This transaction has been approved'
         else
-          response["auth_response_text"]
+          response['auth_response_text']
         end
       end
 
@@ -168,7 +186,7 @@ module ActiveMerchant #:nodoc:
         post[:profile_key] = @options[:password]
         post[:transaction_type] = action if action
 
-        request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+        request = post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
         request
       end
     end

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

@@ -1,4 +1,4 @@
-require "cgi"
+require 'cgi'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -8,7 +8,6 @@ module ActiveMerchant #:nodoc:
         def configure_ssl(http)
           super(http)
           http.use_ssl = true
-          http.ssl_version = :SSLv3
         end
       end
 
@@ -47,7 +46,7 @@ module ActiveMerchant #:nodoc:
 
       def capture(money, authorization, options = {})
         post = {}
-        post.merge!(:transactionid => authorization)
+        post[:transactionid] = authorization
         add_amount(post, money, options)
         commit('capture', money, post)
       end
@@ -76,40 +75,39 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_creditcard(post, creditcard)
-       post['cvv'] = creditcard.verification_value
-       post['ccnumber'] = creditcard.number
-       post['ccexp'] =  "#{sprintf("%02d", creditcard.month)}#{"#{creditcard.year}"[-2, 2]}"
+        post['cvv'] = creditcard.verification_value
+        post['ccnumber'] = creditcard.number
+        post['ccexp'] = "#{sprintf("%02d", creditcard.month)}#{creditcard.year.to_s[-2, 2]}"
       end
 
       def commit(action, money, parameters={})
         parameters['username'] = @options[:username]
         parameters['password'] = @options[:password]
-        parse(ssl_post(BASE_URL,post_data(action, parameters)))
+        parse(ssl_post(BASE_URL, post_data(action, parameters)))
       end
 
       def post_data(action, parameters = {})
-        parameters.merge!({:type => action})
-        ret = ""
+        parameters[:type] = action
+        ret = ''
         for key in parameters.keys
           ret += "#{key}=#{CGI.escape(parameters[key].to_s)}"
           if key != parameters.keys.last
-            ret += "&"
+            ret += '&'
           end
         end
         ret.to_s
       end
 
       def parse(data)
-        responses =  CGI.parse(data).inject({}){|h,(k, v)| h[k] = v.first; h}
+        responses =  CGI.parse(data).inject({}) { |h, (k, v)| h[k] = v.first; h }
         Response.new(
-          (responses["response"].to_i == 1),
-          responses["responsetext"],
+          (responses['response'].to_i == 1),
+          responses['responsetext'],
           responses,
           :test => test?,
-          :authorization => responses["transactionid"]
+          :authorization => responses['transactionid']
         )
       end
     end
   end
 end
-