activemerchant 1.38.0 → 1.79.2

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

@@ -0,0 +1,262 @@
+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
+
+      CARD_BRAND = {
+        "american_express" => "amex",
+        "diners_club" => "diners"
+      }
+
+      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.merge!(card_brand: (CARD_BRAND[payment.brand] || payment.brand))
+          options.merge!(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.merge!(card_brand: (CARD_BRAND[payment.brand] || payment.brand))
+          options.merge!(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)
+        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.merge!(capture: false)
+        post
+      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[:payment_method_id] = options[:card_brand]
+      end
+
+      def parse(body)
+        JSON.parse(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["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,6 +138,13 @@ 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|
@@ -148,12 +173,6 @@ module ActiveMerchant #:nodoc:
         )
       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"

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

@@ -8,7 +8,6 @@ module ActiveMerchant #:nodoc:
         def configure_ssl(http)
           super(http)
           http.use_ssl = true
-          http.ssl_version = :SSLv3
         end
       end
 

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

@@ -0,0 +1,245 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MerchantPartnersGateway < Gateway
+      self.display_name = "Merchant Partners"
+      self.homepage_url = "http://www.merchantpartners.com/"
+
+      self.live_url = "https://trans.merchantpartners.com/cgi-bin/ProcessXML.cgi"
+
+      self.supported_countries = ["US"]
+      self.default_currency = "USD"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+      def initialize(options={})
+        requires!(options, :account_id, :merchant_pin)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit(payment_method.is_a?(String) ? :stored_purchase : :purchase, post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit(:authorize, post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit(:capture, post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+
+        commit(:void, post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit(:refund, post)
+      end
+
+      def credit(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+
+        commit(payment_method.is_a?(String) ? :stored_credit : :credit, 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 store(payment_method, options = {})
+        post = {}
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        post[:profileactiontype] = options[:profileactiontype] || STORE_TX_TYPES[:store_only]
+
+        commit(:store, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<ccnum>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<cvv2>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<merchantpin>)[^<]+(<))i, '\1[FILTERED]\2')
+      end
+
+      def test?
+        @options[:account_id].eql?('TEST0')
+      end
+
+      private
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:merchantordernumber] = options[:order_id]
+        post[:currency] = options[:currency] || currency(money)
+      end
+
+      def add_payment_method(post, payment_method)
+        if(payment_method.is_a?(String))
+          user_profile_id, last_4 = split_authorization(payment_method)
+          post[:userprofileid] = user_profile_id
+          post[:last4digits] = last_4
+        else
+          post[:ccname] = payment_method.name
+          post[:ccnum] = payment_method.number
+          post[:cvv2] = payment_method.verification_value
+          post[:expmon] = format(payment_method.month, :two_digits)
+          post[:expyear] = format(payment_method.year, :four_digits)
+          post[:swipedata] = payment_method.track_data if payment_method.track_data
+        end
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] if options[:email]
+        post[:ipaddress] = options[:ip] if options[:ip]
+        if(billing_address = options[:billing_address])
+          post[:billaddr1] = billing_address[:address1]
+          post[:billaddr2] = billing_address[:address2]
+          post[:billcity] = billing_address[:city]
+          post[:billstate] = billing_address[:state]
+          post[:billcountry] = billing_address[:country]
+          post[:bilzip]    = billing_address[:zip]
+          post[:phone] = billing_address[:phone]
+        end
+      end
+
+      def add_reference(post, authorization)
+        post[:historykeyid] = authorization
+      end
+
+      ACTIONS = {
+        purchase: "2",
+        authorize: "1",
+        capture: "3",
+        void: "5",
+        refund: "4",
+        credit: "6",
+        store: "7",
+        stored_purchase: "8",
+        stored_credit: "13"
+      }
+
+      STORE_TX_TYPES = {
+        store_only: "3"
+      }
+
+      def commit(action, post)
+        post[:acctid] = @options[:account_id]
+        post[:merchantpin] = @options[:merchant_pin]
+        post[:service] = ACTIONS[action] if ACTIONS[action]
+
+        data = build_request(post)
+        response_data = parse(ssl_post(live_url, data, headers))
+        succeeded = success_from(response_data)
+
+        Response.new(
+          succeeded,
+          message_from(succeeded, response_data),
+          response_data,
+          authorization: authorization_from(post, response_data),
+          :avs_result => AVSResult.new(code: response_data["avs_response"]),
+          :cvv_result => CVVResult.new(response_data["cvv2_response"]),
+          test: test?
+        )
+      end
+
+      def headers
+        {
+          "Content-Type"  => "application/xml"
+        }
+      end
+
+      def build_request(post)
+        Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |xml|
+          xml.interface_driver {
+            xml.trans_catalog {
+              xml.transaction(name: "creditcard") {
+                xml.inputs {
+                  post.each do |field, value|
+                    xml.send(field, value)
+                  end
+                }
+              }
+            }
+          }
+        end.to_xml
+      end
+
+      def parse(body)
+        response = {}
+        Nokogiri::XML(CGI.unescapeHTML(body)).xpath("//trans_catalog/transaction/outputs").children.each do |node|
+          parse_element(response, node)
+        end
+        response
+      end
+
+      def parse_element(response, node)
+        if node.elements.size == 0
+          response[node.name.downcase.underscore.to_sym] = node.text
+        else
+          node.elements.each{|element| parse_element(response, element) }
+        end
+      end
+
+      def success_from(response)
+        response[:status] == "Approved"
+      end
+
+      def message_from(succeeded, response)
+        succeeded ? "Succeeded" : error_message_from(response)
+      end
+
+      def authorization_from(request, response)
+        request[:service] == ACTIONS[:store] ?
+          "#{response[:userprofileid]}|#{response[:last4digits]}" :
+          response[:historyid]
+      end
+
+      def split_authorization(authorization)
+        authorization.split("|")
+      end
+
+      def error_message_from(response)
+        if(response[:status] == "Declined")
+          match = response[:result].match(/DECLINED:\d{10}:(.+):/)
+          match[1] if match
+        end
+      end
+    end
+  end
+end

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

@@ -105,7 +105,7 @@ module ActiveMerchant #:nodoc:
       #   * <tt>:order_id</tt> - A unique reference for this order (required when performing a non-referenced credit)
       def credit(money, identification, options = {})
         if identification.is_a?(String)
-          deprecated CREDIT_DEPRECATION_MESSAGE
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
           refund(money, identification, options)
         else
           perform_credit(money, identification, options)
@@ -151,7 +151,7 @@ module ActiveMerchant #:nodoc:
       def build_purchase_request(action, money, credit_card, options)
         requires!(options, :order_id)
 
-        request = soap_request(action) do |xml|
+        soap_request(action) do |xml|
           add_invoice(xml, options)
           add_amount(xml, money)
           add_credit_card(xml, credit_card)
@@ -162,7 +162,7 @@ module ActiveMerchant #:nodoc:
       def build_capture_request(action, money, identification, options)
         reference, options[:order_id] = split_reference(identification)
 
-        request = soap_request(action) do |xml|
+        soap_request(action) do |xml|
           add_reference(xml, reference)
           add_invoice(xml, options)
           add_amount(xml, money)
@@ -199,13 +199,6 @@ module ActiveMerchant #:nodoc:
         xml.tag! "strName", @options[:name]
       end
 
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-
       def add_invoice(xml, options)
         xml.tag! "strOrderNumber", options[:order_id].to_s.gsub(/[^\w]/, '').slice(0, 25)
       end
@@ -230,10 +223,14 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_credit_card(xml, credit_card)
-        xml.tag! "strPAN", credit_card.number
-        xml.tag! "strExpDate", expdate(credit_card)
-        xml.tag! "strCardHolder", credit_card.name
-        xml.tag! "strCVCode", credit_card.verification_value if credit_card.verification_value?
+        if credit_card.respond_to?(:track_data) && credit_card.track_data.present?
+          xml.tag! "trackData", credit_card.track_data
+        else
+         xml.tag! "strPAN", credit_card.number
+         xml.tag! "strExpDate", expdate(credit_card)
+         xml.tag! "strCardHolder", credit_card.name
+         xml.tag! "strCVCode", credit_card.verification_value if credit_card.verification_value?
+        end
       end
 
       def split_reference(reference)
@@ -279,7 +276,7 @@ module ActiveMerchant #:nodoc:
 
         response[:message] = response["faultstring"].to_s.gsub("\n", " ")
         response
-      rescue REXML::ParseException => e
+      rescue REXML::ParseException
         response[:http_body]        = http_response.body
         response[:message]          = "Failed to parse the failed response"
         response