activemerchant 1.133.0 → 1.138.0

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

@@ -0,0 +1,267 @@
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
+    class LoanPaymentProGateway < Gateway
+      self.live_url = 'https://gateway.loanpaymentpro.com'
+      self.test_url = 'https://gateway.loanpaymentpro.com'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://loanpaymentpro.com/'
+      self.display_name = 'LoanPaymentPro'
+
+      RESPONSE_CODE_MAPPING = {
+        1 => 'Customer added successfully.',
+        3 => 'Customer removed successfully.',
+        4 => 'An error occurred while removing the customer.',
+        5 => 'Customer updated successfully.',
+        6 => 'An error occurred while updating the customer.',
+        7 => 'Customer was retrieved successfully.',
+        8 => 'A customer with that token was not found.',
+        9 => 'Customer listing successful.',
+        10 => 'Payment method was removed successfully.',
+        11 => 'An error occurred while removing the payment method.',
+        12 => 'A payment method with that token was not  found.',
+        13 => 'Payment method updated successfully.',
+        14 => 'An error occurred while updating the payment method.',
+        15 => 'Payment method retrieved successfully.',
+        21 => 'Payment method added successfully.',
+        27 => 'Transaction search completed successfully',
+        28 => 'An error occurred while searching transactions.',
+        30 => 'Payment method listing successful.',
+        31 => 'Transaction retrieved sucessfully.',
+        32 => 'A transaction with that ID could not be found.',
+        41 => 'Transaction summary retrieved successfully.',
+        42 => 'Error retrieving transaction summary',
+        46 => 'A transaction with that InvoiceId could not be found.',
+        56 => 'The operation failed to complete successfully.',
+        95 => 'Timeout occurred, transaction not processed.',
+        105 => 'Batch report retrieved successfully.',
+        198 => 'Invalid transaction key to perform this action',
+        254 => 'Portfolio retrieved successfully',
+        275 => 'Invalid transaction type',
+        276 => 'Batch search failed.',
+        376 => 'Pre-Payment created successfully',
+        377 => 'An error occurred while creating the pre-payment',
+        378 => 'Pre-Payment retrieval successful.',
+        379 => 'Invalid pre-payment uniqueId',
+        380 => 'An error occurred while retrieving pre-payment information',
+        382 => 'An error occurred while retrieving pre-payment information',
+        383 => 'Pre-Payment updated successfully',
+        384 => 'Invalid pre-payment uniqueId',
+        385 => 'An error occurred while updating the pre-payment'
+      }
+
+      def initialize(options = {})
+        requires!(options, :transaction_key)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        return delegate_to_ach(:purchase, money, payment, options) if use_ach_gateway?(payment)
+
+        post = {}
+
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+
+        commit(auth_purchase_path(payment, options), post)
+      end
+
+      def authorize(money, payment, options = {})
+        return delegate_to_ach(:authorize, money, payment, options) if use_ach_gateway?(payment)
+
+        options[:action] = :authorize
+        purchase(money, payment, options)
+      end
+
+      def capture(money, authorization, options = {})
+        commit(path(:capture, authorization), {})
+      end
+
+      def refund(money, authorization, options = {})
+        return delegate_to_ach(:refund, money, authorization, options) if use_ach_gateway?(authorization)
+
+        transaction_id, invoice_id = authorization.split('|')
+        post = { Amount: amount(money), InvoiceId: invoice_id }
+
+        commit(path(:refund, transaction_id), post)
+      end
+
+      def void(authorization, options = {})
+        return delegate_to_ach(:void, authorization, options) if use_ach_gateway?(authorization)
+
+        commit(path(:void, authorization), {})
+      end
+
+      def verify(credit_card, options = {})
+        post = {}
+        add_payment(post, credit_card)
+        add_address(post, credit_card, options)
+
+        commit(path(:verify), post)
+      end
+
+      def store(credit_card, options = {})
+        post = {}
+        add_payment(post, credit_card)
+        add_address(post, credit_card, options)
+
+        commit(path(:store), post)
+      end
+
+      def unstore(authorization, options = {})
+        commit(path(:unstore, authorization), {}, :delete)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Transactionkey: )\S+), '\1[FILTERED]').
+          gsub(%r((CardNumber=)\d+), '\1[FILTERED]').
+          gsub(%r((CardCode=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def address_from_options(options)
+        options[:billing_address] || options[:address] || {}
+      end
+
+      def address_names(address_name, payment_method)
+        names = split_names(address_name)
+        return names if names.any?(&:present?)
+
+        [payment_method.try(:first_name), payment_method.try(:last_name)]
+      end
+
+      def add_address(post, payment_method, options)
+        address = address_from_options(options)
+        first_name, last_name = address_names(address[:name], payment_method)
+
+        post.merge!(
+          BillingFirstName: first_name,
+          BillingLastName: last_name,
+          BillingAddress1: address[:address1],
+          BillingAddress2: address[:address2],
+          BillingCity: address[:city],
+          BillingState: address[:state],
+          BillingZip: address[:zip]
+        )
+      end
+
+      def add_invoice(post, money, options)
+        post[:InvoiceId] = options[:order_id]
+        post[:Amount] = amount(money)
+      end
+
+      def add_payment(post, payment)
+        return unless payment.is_a?(CreditCard)
+
+        post.merge!(
+          CardNumber: payment.number,
+          CardCode: payment.verification_value,
+          ExpMonth: format(payment.month, :two_digits),
+          ExpYear: format(payment.year, :two_digits)
+        )
+      end
+
+      def parse(body)
+        JSON.parse(body).with_indifferent_access
+      rescue JSON::ParserError, TypeError => e
+        {
+          errors: body,
+          status: 'Unable to parse JSON response',
+          message: e.message
+        }.with_indifferent_access
+      end
+
+      def path(action, value = '')
+        placeholder = value.to_s.split('|').first || ''
+
+        {
+          purchase: 'v2-3/paymentcards/run',
+          authorize: 'v2-3/paymentcards/authorize',
+          capture: "v2-1/transactions/#{placeholder}/capture",
+          void: "v2/payments/#{placeholder}/void",
+          refund: "v2/payments/#{placeholder}/refund",
+          verify: 'v2/paymentcards/validate/detailed',
+          store: 'v2/paymentcards/add',
+          unstore: "v2/paymentcards/#{placeholder}/delete",
+          authorize_with_token: "v2-3/payments/paymentcards/#{placeholder}/authorize",
+          purchase_with_token: "v2-3/payments/paymentcards/#{placeholder}/run"
+        }[action]
+      end
+
+      def auth_purchase_path(payment, options)
+        action = options.delete(:action) || :purchase
+        pm_token = ''
+
+        if payment.is_a?(String)
+          pm_token = payment
+          action = "#{action}_with_token".to_sym
+        end
+
+        path(action, pm_token)
+      end
+
+      def url(path)
+        "#{test? ? test_url : live_url}/#{path}"
+      end
+
+      def request_headers
+        { TransactionKey: @options[:transaction_key] }
+      end
+
+      def commit(path, post = {}, method = :post, options = {})
+        response = parse(ssl_request(method, url(path), post_data(post), request_headers))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, post),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response[:Status] == 'Success'
+      end
+
+      def message_from(response)
+        response[:Message] || response[:ResponseMessage] || response[:Status]
+      end
+
+      def authorization_from(response = {}, post = {})
+        response[:PaymentMethodToken].presence || [response[:TransactionId], post[:InvoiceId]].compact.join('|')
+      end
+
+      def post_data(params)
+        URI.encode_www_form(params.compact)
+      end
+
+      def error_code_from(response)
+        RESPONSE_CODE_MAPPING[response[:ResponseCode].to_i] unless success_from(response)
+      end
+
+      def ach_gateway
+        @ach_gateway ||= LoanPaymentProAchGateway.new(@options)
+      end
+
+      def use_ach_gateway?(payment_or_auth)
+        payment_or_auth.is_a?(Check) || (payment_or_auth.is_a?(String) && payment_or_auth.include?('|ach'))
+      end
+
+      def delegate_to_ach(method, *args)
+        ach_gateway.public_send(method, *args)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
+    class LoanPaymentProAchGateway < LoanPaymentProGateway
+      self.live_url = 'https://www.checkcommerce.com/EpnPublic/ACH.aspx'
+      self.test_url = 'https://sandbox.checkcommerce.com/EpnPublic/ACH.aspx'
+
+      API_VERSION = '1.4.2.36'.freeze
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, bank_account, options = {})
+        post = {
+          Method: options.delete(:method) || :Debit,
+          ReferenceNumber: options[:order_id] || SecureRandom.uuid,
+          Name: bank_account.name,
+          Amount: amount(money),
+          RoutingNumber: bank_account.routing_number,
+          AccountNumber: bank_account.account_number
+        }
+
+        commit(post)
+      end
+
+      def authorize(money, bank_account, options = {})
+        purchase(money, bank_account, options.merge(method: :Authorize))
+      end
+
+      def void(authorization, options = {})
+        post = {
+          Method: :Cancel,
+          TransactionId: authorization.to_s.split('|').first
+        }
+        commit(post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {
+          Method: :Refund,
+          TransactionId: authorization.to_s.split('|').first,
+          Amount: amount(money)
+        }
+        commit(post)
+      end
+
+      private
+
+      def add_credentials_and_version(post)
+        post.merge!({
+          Login: @options[:login],
+          Password: @options[:password],
+          Version: API_VERSION
+        })
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def commit(post = {}, method = :post, options = {})
+        add_credentials_and_version(post)
+        response = parse(ssl_request(method, url, post_data(post), {}))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def parse(response_body)
+        URI.decode_www_form(response_body.gsub(/\r\n/, '&')).to_h.with_indifferent_access
+      end
+
+      def success_from(response)
+        response[:Success].to_s.downcase == 'true'
+      end
+
+      def message_from(response)
+        response[:Message]
+      end
+
+      def authorization_from(response = {})
+        "#{response[:TransactionID]}|ach"
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module ActiveMerchant
         if options[:pay_mode]
           post = new_post
           add_invoice(post, amount, options)
-          add_reference(post, *new_authorization)
+          add_reference(post, *new_authorization(options))
           add_payment_method(post, payment_method)
           add_customer_data(post, payment_method, options)
           add_3dsecure_id(post, options)
@@ -27,7 +27,7 @@ module ActiveMerchant
       def authorize(amount, payment_method, options = {})
         post = new_post
         add_invoice(post, amount, options)
-        add_reference(post, *new_authorization)
+        add_reference(post, *new_authorization(options))
         add_payment_method(post, payment_method)
         add_customer_data(post, payment_method, options)
         add_3dsecure_id(post, options)
@@ -264,9 +264,9 @@ module ActiveMerchant
         authorization.split('|')
       end
 
-      def new_authorization
+      def new_authorization(options)
         # Must be unique within a merchant id.
-        orderid = SecureRandom.uuid
+        orderid = options[:order_id] || SecureRandom.uuid
 
         # Must be unique within an order id.
         transactionid = '1'

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class MaxipagoGateway < Gateway
       API_VERSION = '3.1.1.15'
 
@@ -79,8 +79,8 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      def commit(action)
-        request = build_xml_request(action) { |doc| yield(doc) }
+      def commit(action, &block)
+        request = build_xml_request(action, &block)
         response = parse(ssl_post(url, request, 'Content-Type' => 'text/xml'))
 
         Response.new(

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

@@ -1,10 +1,12 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class MercadoPagoGateway < Gateway
-      self.live_url = self.test_url = 'https://api.mercadopago.com/v1'
+      version 'v1'
+
+      self.live_url = self.test_url = "https://api.mercadopago.com/#{fetch_version}"
 
       self.supported_countries = %w[AR BR CL CO MX PE UY]
-      self.supported_cardtypes = %i[visa master american_express elo cabal naranja creditel]
+      self.supported_cardtypes = %i[visa master american_express elo cabal naranja creditel patagonia_365 tarjeta_sol]
 
       self.homepage_url = 'https://www.mercadopago.com/'
       self.display_name = 'Mercado Pago'
@@ -43,6 +45,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         authorization, original_amount = authorization.split('|')
         post[:amount] = amount(money).to_f if original_amount && original_amount.to_f > amount(money).to_f
+        add_idempotency_key(post, options)
         commit('refund', "payments/#{authorization}/refunds", post)
       end
 
@@ -85,7 +88,7 @@ module ActiveMerchant #:nodoc:
         post[:expiration_month] = payment.month
         post[:expiration_year] = payment.year
         post[:cardholder] = {
-          name: payment.name,
+          name: format_name(payment.name),
           identification: {
             type: options[:cardholder_identification_type],
             number: options[:cardholder_identification_number]
@@ -105,7 +108,9 @@ module ActiveMerchant #:nodoc:
         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])
+        add_idempotency_key(post, options)
+        add_3ds(post, options)
+        post[:binary_mode] = options.fetch(:binary_mode, true) unless options[:execute_threed]
         post
       end
 
@@ -134,7 +139,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_additional_data(post, options)
-        post[:sponsor_id] = options[:sponsor_id]
+        post[:sponsor_id] = options[:sponsor_id] unless test?
         post[:metadata] = options[:metadata] if options[:metadata]
         post[:device_id] = options[:device_id] if options[:device_id]
         post[:additional_info] = {
@@ -148,8 +153,8 @@ module ActiveMerchant #:nodoc:
       def add_customer_data(post, payment, options)
         post[:payer] = {
           email: options[:email],
-          first_name: payment.first_name,
-          last_name: payment.last_name
+          first_name: format_name(payment.first_name),
+          last_name: format_name(payment.last_name)
         }.merge(options[:payer] || {})
       end
 
@@ -211,6 +216,10 @@ module ActiveMerchant #:nodoc:
         post[:net_amount] = Float(options[:net_amount]) if options[:net_amount]
       end
 
+      def add_idempotency_key(post, options)
+        post[:idempotency_key] = options[:idempotency_key] if options[:idempotency_key]
+      end
+
       def add_notification_url(post, options)
         post[:notification_url] = options[:notification_url] if options[:notification_url]
       end
@@ -287,7 +296,7 @@ module ActiveMerchant #:nodoc:
         if action == 'refund'
           response['status'] != 404 && response['error'].nil?
         else
-          %w[active approved authorized cancelled in_process].include?(response['status'])
+          %w[active approved authorized cancelled in_process pending].include?(response['status'])
         end
       end
 
@@ -300,7 +309,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def post_data(parameters = {})
-        parameters.clone.tap { |p| p.delete(:device_id) }.to_json
+        params = parameters.clone.tap do |p|
+          p.delete(:device_id)
+          p.delete(:idempotency_key)
+        end
+        params.to_json
       end
 
       def inquire_path(authorization, options)
@@ -322,6 +335,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_3ds(post, options)
+        return unless options[:execute_threed]
+
+        post[:three_d_secure_mode] = options[:three_ds_mode] == 'mandatory' ? 'mandatory' : 'optional'
+        post[:notification_url] = options[:notification_url] if options[:notification_url]
+      end
+
       def url(action)
         full_url = (test? ? test_url : live_url)
         full_url + "/#{action}?access_token=#{CGI.escape(@options[:access_token])}"
@@ -332,6 +352,7 @@ module ActiveMerchant #:nodoc:
           'Content-Type' => 'application/json'
         }
         headers['X-meli-session-id'] = options[:device_id] if options[:device_id]
+        headers['X-Idempotency-Key'] = options[:idempotency_key] if options[:idempotency_key]
         headers
       end
 

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class MerchantESolutionsGateway < Gateway
       include Empty
 
@@ -180,7 +180,7 @@ 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 !(action == 'V') && money
 
         response =
           begin
@@ -189,11 +189,15 @@ module ActiveMerchant #:nodoc:
             { 'error_code' => '404', 'auth_response_text' => e.to_s }
           end
 
-        Response.new(success_from(response), message_from(response), response,
+        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'] })
+          avs_result: { code: response['avs_result'] }
+        )
       end
 
       def authorization_from(response)
@@ -220,8 +224,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('&')
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'cgi'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class MerchantOneGateway < Gateway
       class MerchantOneSslConnection < ActiveMerchant::Connection
         def configure_ssl(http)

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class MerchantPartnersGateway < Gateway
       self.display_name = 'Merchant Partners'
       self.homepage_url = 'http://www.merchantpartners.com/'

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class MerchantWareGateway < Gateway
       class_attribute :v4_live_url
 
@@ -290,19 +290,26 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, request, v4 = false)
         begin
-          data = ssl_post(url(v4), request,
+          data = ssl_post(
+            url(v4),
+            request,
             'Content-Type' => 'text/xml; charset=utf-8',
-            'SOAPAction'   => soap_action(action, v4))
+            'SOAPAction'   => soap_action(action, v4)
+          )
           response = parse(action, data)
         rescue ActiveMerchant::ResponseError => e
           response = parse_error(e.response)
         end
 
-        Response.new(response[:success], response[:message], response,
+        Response.new(
+          response[:success],
+          response[:message],
+          response,
           test: test?,
           authorization: authorization_from(response),
           avs_result: { code: response['AVSResponse'] },
-          cvv_result: response['CVResponse'])
+          cvv_result: response['CVResponse']
+        )
       end
 
       def authorization_from(response)

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class MerchantWareVersionFourGateway < Gateway
       self.live_url = 'https://ps1.merchantware.net/Merchantware/ws/RetailTransaction/v4/Credit.asmx'
       self.test_url = 'https://ps1.merchantware.net/Merchantware/ws/RetailTransaction/v4/Credit.asmx'
@@ -261,19 +261,26 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, request)
         begin
-          data = ssl_post(url, request,
+          data = ssl_post(
+            url,
+            request,
             'Content-Type' => 'text/xml; charset=utf-8',
-            'SOAPAction'   => soap_action(action))
+            'SOAPAction'   => soap_action(action)
+          )
           response = parse(action, data)
         rescue ActiveMerchant::ResponseError => e
           response = parse_error(e.response, action)
         end
 
-        Response.new(response[:success], response[:message], response,
+        Response.new(
+          response[:success],
+          response[:message],
+          response,
           test: test?,
           authorization: authorization_from(response),
           avs_result: { code: response['AvsResponse'] },
-          cvv_result: response['CvResponse'])
+          cvv_result: response['CvResponse']
+        )
       end
 
       def authorization_from(response)