activemerchant 1.100.0 → 1.133.0

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

@@ -1,12 +1,12 @@
 module ActiveMerchant
   module Billing
     module MastercardGateway
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :userid, :password)
         super
       end
 
-      def purchase(amount, payment_method, options={})
+      def purchase(amount, payment_method, options = {})
         if options[:pay_mode]
           post = new_post
           add_invoice(post, amount, options)
@@ -24,7 +24,7 @@ module ActiveMerchant
         end
       end
 
-      def authorize(amount, payment_method, options={})
+      def authorize(amount, payment_method, options = {})
         post = new_post
         add_invoice(post, amount, options)
         add_reference(post, *new_authorization)
@@ -35,7 +35,7 @@ module ActiveMerchant
         commit('authorize', post)
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         post = new_post
         add_invoice(post, amount, options, :transaction)
         add_reference(post, *next_authorization(authorization))
@@ -45,7 +45,7 @@ module ActiveMerchant
         commit('capture', post)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         post = new_post
         add_invoice(post, amount, options, :transaction)
         add_reference(post, *next_authorization(authorization))
@@ -54,14 +54,14 @@ module ActiveMerchant
         commit('refund', post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = new_post
         add_reference(post, *next_authorization(authorization), :targetTransactionId)
 
         commit('void', post)
       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) }
@@ -105,16 +105,16 @@ module ActiveMerchant
           billing: {},
           device: {},
           shipping: {},
-          transaction: {},
+          transaction: {}
         }
       end
 
-      def add_invoice(post, amount, options, node=:order)
+      def add_invoice(post, amount, options, node = :order)
         post[node][:amount] = amount(amount)
         post[node][:currency] = (options[:currency] || currency(amount))
       end
 
-      def add_reference(post, orderid, transactionid, transaction_reference, reference_key=:reference)
+      def add_reference(post, orderid, transactionid, transaction_reference, reference_key = :reference)
         post[:orderid] = orderid
         post[:transactionid] = transactionid
         post[:transaction][reference_key] = transaction_reference if transaction_reference
@@ -175,7 +175,8 @@ module ActiveMerchant
 
       def add_3dsecure_id(post, options)
         return unless options[:threed_secure_id]
-        post.merge!({'3DSecureId' => options[:threed_secure_id]})
+
+        post.merge!({ '3DSecureId' => options[:threed_secure_id] })
       end
 
       def country_code(country)
@@ -189,7 +190,7 @@ module ActiveMerchant
       def headers
         {
           'Authorization' => 'Basic ' + Base64.encode64("merchant.#{@options[:userid]}:#{@options[:password]}").strip.delete("\r\n"),
-          'Content-Type' => 'application/json',
+          'Content-Type' => 'application/json'
         }
       end
 
@@ -206,8 +207,8 @@ module ActiveMerchant
           succeeded,
           message_from(succeeded, raw),
           raw,
-          :authorization => authorization_from(post, raw),
-          :test => test?
+          authorization: authorization_from(post, raw),
+          test: test?
         )
       end
 
@@ -217,14 +218,7 @@ module ActiveMerchant
 
       def base_url
         if test?
-          case @options[:region]
-          when 'asia_pacific'
-            test_ap_url
-          when 'europe'
-            test_eu_url
-          when 'north_america', nil
-            test_na_url
-          end
+          test_url
         else
           case @options[:region]
           when 'asia_pacific'

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

@@ -11,7 +11,7 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = ['BR']
       self.default_currency = 'BRL'
       self.money_format = :dollars
-      self.supported_cardtypes = [:visa, :master, :discover, :american_express, :diners_club]
+      self.supported_cardtypes = %i[visa master discover american_express diners_club]
       self.homepage_url = 'http://www.maxipago.com/'
       self.display_name = 'maxiPago!'
 
@@ -212,7 +212,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_order_id(xml, authorization)
-        order_id, _ = split_authorization(authorization)
+        order_id, = split_authorization(authorization)
         xml.orderID order_id
       end
     end

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

@@ -3,19 +3,19 @@ module ActiveMerchant #: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, :elo, :cabal, :naranja]
+      self.supported_countries = %w[AR BR CL CO MX PE UY]
+      self.supported_cardtypes = %i[visa master american_express elo cabal naranja creditel]
 
       self.homepage_url = 'https://www.mercadopago.com/'
       self.display_name = 'Mercado Pago'
       self.money_format = :dollars
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :access_token)
         super
       end
 
-      def purchase(money, payment, options={})
+      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
@@ -23,7 +23,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def authorize(money, payment, options={})
+      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
@@ -31,34 +31,40 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
-        authorization, _ = authorization.split('|')
+        authorization, = authorization.split('|')
         post[:capture] = true
         post[:transaction_amount] = amount(money).to_f
         commit('capture', "payments/#{authorization}", post)
       end
 
-      def refund(money, authorization, options={})
+      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('|')
+      def void(authorization, options = {})
+        authorization, = authorization.split('|')
         post = { status: 'cancelled' }
         commit('void', "payments/#{authorization}", post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
+        verify_amount = 100
+        verify_amount = options[:amount].to_i if options[:amount]
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, credit_card, options) }
+          r.process { authorize(verify_amount, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
 
+      def inquire(authorization, options = {})
+        commit('inquire', inquire_path(authorization, options), {})
+      end
+
       def supports_scrubbing?
         true
       end
@@ -96,25 +102,31 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, payment, options)
         add_address(post, options)
         add_processing_mode(post, options)
+        add_net_amount(post, options)
+        add_taxes(post, options)
+        add_notification_url(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[:capture] = options[: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]
+        post[:payment_method_option_id] = options[:payment_method_option_id] if options[:payment_method_option_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]
@@ -123,6 +135,7 @@ module ActiveMerchant #:nodoc:
 
       def add_additional_data(post, options)
         post[:sponsor_id] = options[:sponsor_id]
+        post[:metadata] = options[:metadata] if options[:metadata]
         post[:device_id] = options[:device_id] if options[:device_id]
         post[:additional_info] = {
           ip_address: options[:ip_address]
@@ -137,7 +150,7 @@ module ActiveMerchant #:nodoc:
           email: options[:email],
           first_name: payment.first_name,
           last_name: payment.last_name
-        }
+        }.merge(options[:payer] || {})
       end
 
       def add_address(post, options)
@@ -185,7 +198,7 @@ module ActiveMerchant #:nodoc:
         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)
+        post[:external_reference] = options[:order_id] || options[:external_reference] || SecureRandom.hex(16)
       end
 
       def add_payment(post, options)
@@ -194,6 +207,51 @@ module ActiveMerchant #:nodoc:
         post[:payment_method_id] = options[:payment_method_id] if options[:payment_method_id]
       end
 
+      def add_net_amount(post, options)
+        post[:net_amount] = Float(options[:net_amount]) if options[:net_amount]
+      end
+
+      def add_notification_url(post, options)
+        post[:notification_url] = options[:notification_url] if options[:notification_url]
+      end
+
+      def add_taxes(post, options)
+        return unless (tax_object = options[:taxes])
+
+        if tax_object.is_a?(Array)
+          post[:taxes] = process_taxes_array(tax_object)
+        elsif tax_object.is_a?(Hash)
+          post[:taxes] = process_taxes_hash(tax_object)
+        else
+          raise taxes_error
+        end
+      end
+
+      def process_taxes_hash(tax_object)
+        [sanitize_taxes_hash(tax_object)]
+      end
+
+      def process_taxes_array(taxes_array)
+        taxes_array.map do |tax_object|
+          raise taxes_error unless tax_object.is_a?(Hash)
+
+          sanitize_taxes_hash(tax_object)
+        end
+      end
+
+      def sanitize_taxes_hash(tax_object)
+        tax_value = tax_object['value'] || tax_object[:value]
+        tax_type = tax_object['type'] || tax_object[:type]
+
+        raise taxes_error if tax_value.nil? || tax_type.nil?
+
+        { value: Float(tax_value), type: tax_type }
+      end
+
+      def taxes_error
+        ArgumentError.new("Taxes should be a single object or array of objects with the shape: { value: 500, type: 'IVA' }")
+      end
+
       def parse(body)
         JSON.parse(body)
       rescue JSON::ParserError
@@ -205,8 +263,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, path, parameters)
-        if ['capture', 'void'].include?(action)
+        if %w[capture void].include?(action)
           response = parse(ssl_request(:put, url(path), post_data(parameters), headers))
+        elsif action == 'inquire'
+          response = parse(ssl_get(url(path), headers))
+
+          response = response[0]['results'][0] if response.is_a?(Array)
         else
           response = parse(ssl_post(url(path), post_data(parameters), headers(parameters)))
         end
@@ -225,7 +287,7 @@ module ActiveMerchant #:nodoc:
         if action == 'refund'
           response['status'] != 404 && response['error'].nil?
         else
-          ['active', 'approved', 'authorized', 'cancelled', 'in_process'].include?(response['status'])
+          %w[active approved authorized cancelled in_process].include?(response['status'])
         end
       end
 
@@ -241,6 +303,15 @@ module ActiveMerchant #:nodoc:
         parameters.clone.tap { |p| p.delete(:device_id) }.to_json
       end
 
+      def inquire_path(authorization, options)
+        if authorization
+          authorization, = authorization.split('|')
+          "payments/#{authorization}"
+        else
+          "payments/search?external_reference=#{options[:order_id] || options[:external_reference]}"
+        end
+      end
+
       def error_code_from(action, response)
         unless success_from(action, response)
           if cause = response['cause']
@@ -260,7 +331,7 @@ module ActiveMerchant #:nodoc:
         headers = {
           'Content-Type' => 'application/json'
         }
-        headers['X-Device-Session-ID'] = options[:device_id] if options[:device_id]
+        headers['X-meli-session-id'] = options[:device_id] if options[:device_id]
         headers
       end
 

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

@@ -10,7 +10,7 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = ['US']
 
       # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb]
+      self.supported_cardtypes = %i[visa master american_express discover jcb]
 
       # The homepage URL of the gateway
       self.homepage_url = 'http://www.merchante-solutions.com/'
@@ -18,6 +18,8 @@ module ActiveMerchant #:nodoc:
       # The name of the gateway
       self.display_name = 'Merchant e-Solutions'
 
+      SUCCESS_RESPONSE_CODES = %w(000 085)
+
       def initialize(options = {})
         requires!(options, :login, :password)
         super
@@ -25,28 +27,26 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, creditcard_or_card_id, options = {})
         post = {}
-        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
-        post[:moto_ecommerce_ind] = options[:moto_ecommerce_ind] if options.has_key?(:moto_ecommerce_ind)
         add_invoice(post, options)
         add_payment_source(post, creditcard_or_card_id, options)
         add_address(post, options)
         add_3dsecure_params(post, options)
+        add_stored_credentials(post, options)
         commit('P', money, post)
       end
 
       def purchase(money, creditcard_or_card_id, options = {})
         post = {}
-        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
-        post[:moto_ecommerce_ind] = options[:moto_ecommerce_ind] if options.has_key?(:moto_ecommerce_ind)
         add_invoice(post, options)
         add_payment_source(post, creditcard_or_card_id, options)
         add_address(post, options)
         add_3dsecure_params(post, options)
+        add_stored_credentials(post, options)
         commit('D', money, post)
       end
 
       def capture(money, transaction_id, options = {})
-        post ={}
+        post = {}
         post[:transaction_id] = transaction_id
         post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
         add_invoice(post, options)
@@ -55,10 +55,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def store(creditcard, options = {})
-        post = {}
-        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
-        add_creditcard(post, creditcard, options)
-        commit('T', nil, post)
+        MultiResponse.run do |r|
+          r.process { temporary_store(creditcard, options) }
+          r.process { verify(r.authorization, { store_card: 'y' }) }
+        end
       end
 
       def unstore(card_id, options = {})
@@ -94,6 +94,13 @@ module ActiveMerchant #:nodoc:
         commit('V', nil, options.merge(post))
       end
 
+      def verify(credit_card, options = {})
+        post = {}
+        post[:store_card] = options[:store_card] if options[:store_card]
+        add_payment_source(post, credit_card, options)
+        commit('A', 0, post)
+      end
+
       def supports_scrubbing?
         true
       end
@@ -107,6 +114,13 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def temporary_store(creditcard, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        add_creditcard(post, creditcard, options)
+        commit('T', nil, post)
+      end
+
       def add_address(post, options)
         if address = options[:billing_address] || options[:address]
           post[:cardholder_street_address] = address[:address1].to_s.gsub(/[^\w.]/, '+')
@@ -133,9 +147,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_creditcard(post, creditcard, options)
-        post[:card_number]  = creditcard.number
+        post[:card_number] = creditcard.number
         post[:cvv2] = creditcard.verification_value if creditcard.verification_value?
-        post[:card_exp_date]  = expdate(creditcard)
+        post[:card_exp_date] = expdate(creditcard)
       end
 
       def add_3dsecure_params(post, options)
@@ -145,6 +159,16 @@ module ActiveMerchant #:nodoc:
         post[:ucaf_auth_data] = options[:ucaf_auth_data] unless empty?(options[:ucaf_auth_data])
       end
 
+      def add_stored_credentials(post, options)
+        post[:client_reference_number] = options[:client_reference_number] if options[:client_reference_number]
+        post[:moto_ecommerce_ind] = options[:moto_ecommerce_ind] if options[:moto_ecommerce_ind]
+        post[:recurring_pmt_num] = options[:recurring_pmt_num] if options[:recurring_pmt_num]
+        post[:recurring_pmt_count] = options[:recurring_pmt_count] if options[:recurring_pmt_count]
+        post[:card_on_file] = options[:card_on_file] if options[:card_on_file]
+        post[:cit_mit_indicator] = options[:cit_mit_indicator] if options[:cit_mit_indicator]
+        post[:account_data_source] = options[:account_data_source] if options[:account_data_source]
+      end
+
       def parse(body)
         results = {}
         body.split(/&/).each do |pair|
@@ -156,20 +180,30 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, money, parameters)
         url = test? ? self.test_url : self.live_url
-        parameters[:transaction_amount]  = amount(money) if money unless action == 'V'
+        parameters[:transaction_amount] = amount(money) if money unless action == 'V'
 
-        response = begin
-          parse(ssl_post(url, post_data(action, parameters)))
-        rescue ActiveMerchant::ResponseError => e
-          { 'error_code' => '404',  'auth_response_text' => e.to_s }
-        end
+        response =
+          begin
+            parse(ssl_post(url, post_data(action, parameters)))
+          rescue ActiveMerchant::ResponseError => e
+            { 'error_code' => '404', 'auth_response_text' => e.to_s }
+          end
+
+        Response.new(success_from(response), message_from(response), response,
+          authorization: authorization_from(response),
+          test: test?,
+          cvv_result: response['cvv2_result'],
+          avs_result: { code: response['avs_result'] })
+      end
+
+      def authorization_from(response)
+        return response['card_id'] if response['card_id']
+
+        response['transaction_id']
+      end
 
-        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'] }
-        )
+      def success_from(response)
+        SUCCESS_RESPONSE_CODES.include?(response['error_code'])
       end
 
       def message_from(response)

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

@@ -3,7 +3,6 @@ require 'cgi'
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class MerchantOneGateway < Gateway
-
       class MerchantOneSslConnection < ActiveMerchant::Connection
         def configure_ssl(http)
           super(http)
@@ -14,7 +13,7 @@ module ActiveMerchant #:nodoc:
       BASE_URL = 'https://secure.merchantonegateway.com/api/transact.php'
 
       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://merchantone.com/'
       self.display_name = 'Merchant One Gateway'
       self.money_format = :dollars
@@ -77,10 +76,10 @@ module ActiveMerchant #:nodoc:
       def add_creditcard(post, creditcard)
         post['cvv'] = creditcard.verification_value
         post['ccnumber'] = creditcard.number
-        post['ccexp'] = "#{sprintf("%02d", creditcard.month)}#{creditcard.year.to_s[-2, 2]}"
+        post['ccexp'] = "#{sprintf('%02d', creditcard.month)}#{creditcard.year.to_s[-2, 2]}"
       end
 
-      def commit(action, money, parameters={})
+      def commit(action, money, parameters = {})
         parameters['username'] = @options[:username]
         parameters['password'] = @options[:password]
         parse(ssl_post(BASE_URL, post_data(action, parameters)))
@@ -91,21 +90,19 @@ module ActiveMerchant #:nodoc:
         ret = ''
         for key in parameters.keys
           ret += "#{key}=#{CGI.escape(parameters[key].to_s)}"
-          if key != parameters.keys.last
-            ret += '&'
-          end
+          ret += '&' if key != parameters.keys.last
         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,
-          :test => test?,
-          :authorization => responses['transactionid']
+          test: test?,
+          authorization: responses['transactionid']
         )
       end
     end