activemerchant 1.133.0 → 1.137.0

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

@@ -0,0 +1,223 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SumUpGateway < Gateway
+      self.live_url = 'https://api.sumup.com/v0.1/'
+
+      self.supported_countries = %w(AT BE BG BR CH CL CO CY CZ DE DK EE ES FI FR
+                                    GB GR HR HU IE IT LT LU LV MT NL NO PL PT RO
+                                    SE SI SK US)
+      self.currencies_with_three_decimal_places = %w(EUR BGN BRL CHF CZK DKK GBP
+                                                     HUF NOK PLN SEK USD)
+      self.default_currency = 'USD'
+
+      self.homepage_url = 'https://www.sumup.com/'
+      self.display_name = 'SumUp'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        multiple_invalid_parameters: 'MULTIPLE_INVALID_PARAMETERS'
+      }
+
+      def initialize(options = {})
+        requires!(options, :access_token, :pay_to_email)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        MultiResponse.run do |r|
+          r.process { create_checkout(money, payment, options) } unless options[:checkout_id]
+          r.process { complete_checkout(options[:checkout_id] || r.params['id'], payment, options) }
+        end
+      end
+
+      def refund(money, authorization, options = {})
+        transaction_id = authorization.split('#').last
+        post = money ? { amount: amount(money) } : {}
+        add_merchant_data(post, options)
+
+        commit('me/refund/' + transaction_id, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Bearer )\w+), '\1[FILTERED]').
+          gsub(%r(("pay_to_email\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cvv\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def create_checkout(money, payment, options)
+        post = {}
+
+        add_merchant_data(post, options)
+        add_invoice(post, money, options)
+        add_address(post, options)
+        add_customer_data(post, payment, options)
+        add_3ds_data(post, options)
+
+        commit('checkouts', post)
+      end
+
+      def complete_checkout(checkout_id, payment, options = {})
+        post = {}
+
+        add_payment(post, payment, options)
+
+        commit('checkouts/' + checkout_id, post, :put)
+      end
+
+      def add_customer_data(post, payment, options)
+        post[:customer_id]      = options[:customer_id]
+        post[:personal_details] = {
+          email:      options[:email],
+          first_name: payment&.first_name,
+          last_name:  payment&.last_name,
+          tax_id:     options[:tax_id]
+        }
+      end
+
+      def add_merchant_data(post, options)
+        # Required field: pay_to_email
+        # Description: Email address of the merchant to whom the payment is made.
+        post[:pay_to_email] = @options[:pay_to_email]
+      end
+
+      def add_address(post, options)
+        post[:personal_details] ||= {}
+        if address = (options[:billing_address] || options[:shipping_address] || options[:address])
+          post[:personal_details][:address] = {
+            city:        address[:city],
+            state:       address[:state],
+            country:     address[:country],
+            line_1:      address[:address1],
+            postal_code: address[:zip]
+          }
+        end
+      end
+
+      def add_invoice(post, money, options)
+        post[:checkout_reference] = options[:order_id]
+        post[:amount]             = amount(money)
+        post[:currency]           = options[:currency] || currency(money)
+        post[:description]        = options[:description]
+      end
+
+      def add_payment(post, payment, options)
+        post[:payment_type] = options[:payment_type] || 'card'
+
+        post[:card] = {
+          name:         payment.name,
+          number:       payment.number,
+          expiry_month: format(payment.month, :two_digits),
+          expiry_year:  payment.year,
+          cvv:          payment.verification_value
+        }
+      end
+
+      def add_3ds_data(post, options)
+        post[:redirect_url] = options[:redirect_url] if options[:redirect_url]
+      end
+
+      def commit(action, post, method = :post)
+        response = api_request(action, post.compact, method)
+        succeeded = success_from(response)
+
+        Response.new(
+          succeeded,
+          message_from(succeeded, response),
+          action.include?('refund') ? { response_code: response.to_s } : response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: error_code_from(succeeded, response)
+        )
+      end
+
+      def api_request(action, post, method)
+        raw_response =
+          begin
+            ssl_request(method, live_url + action, post.to_json, auth_headers)
+          rescue ResponseError => e
+            e.response.body
+          end
+        response = parse(raw_response)
+        response = response.is_a?(Hash) ? response.symbolize_keys : response
+
+        return format_errors(response) if raw_response.include?('error_code') && response.is_a?(Array)
+
+        response
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        (response.is_a?(Hash) && response[:next_step]) ||
+          response == 204 ||
+          %w(PENDING PAID).include?(response[:status]) ||
+          response[:transactions]&.all? { |transaction| transaction.symbolize_keys[:status] == 'SUCCESSFUL' }
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          return 'Succeeded' if (response.is_a?(Hash) && response[:next_step]) || response == 204
+
+          return response[:status]
+        end
+
+        response[:message] || response[:error_message] || response[:status]
+      end
+
+      def authorization_from(response)
+        return nil if response.is_a?(Integer)
+
+        return response[:id] unless response[:transaction_id]
+
+        [response[:id], response[:transaction_id]].join('#')
+      end
+
+      def auth_headers
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{options[:access_token]}"
+        }
+      end
+
+      def error_code_from(succeeded, response)
+        response[:error_code] unless succeeded
+      end
+
+      def format_error(error, key)
+        {
+          :error_code => error['error_code'],
+          key => error['param']
+        }
+      end
+
+      def format_errors(errors)
+        return format_error(errors.first, :message) if errors.size == 1
+
+        return {
+          error_code: STANDARD_ERROR_CODE_MAPPING[:multiple_invalid_parameters],
+          message: 'Validation error',
+          errors: errors.map { |error| format_error(error, :param) }
+        }
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        # to get the response code (204) when the body is nil
+        when 200...300
+          response.body || response.code
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+  end
+end

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

@@ -104,12 +104,14 @@ module ActiveMerchant #:nodoc:
               result = response['data']['result']
               success = (result == 'accepted' || (test? && result == 'test-accepted'))
 
-              Response.new(success,
+              Response.new(
+                success,
                 success ?
                 TRANSACTION_APPROVED_MSG :
                 TRANSACTION_DECLINED_MSG,
                 response,
-                test: test?)
+                test: test?
+              )
             else
               build_error_response(message, response)
             end

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

@@ -162,9 +162,9 @@ module ActiveMerchant #:nodoc:
         country.code(:alpha2)
       end
 
-      def commit(action, amount = nil, currency = nil)
+      def commit(action, amount = nil, currency = nil, &block)
         currency = default_currency if currency == nil
-        request = build_xml_request { |doc| yield(doc) }
+        request = build_xml_request(&block)
         response = ssl_post(live_url, request, headers)
         parsed = parse(response)
 
@@ -231,8 +231,7 @@ module ActiveMerchant #:nodoc:
 
       def authorization_from(action, response, amount, currency)
         auth = response[:tranref]
-        auth = [auth, amount, currency].join('|')
-        auth
+        [auth, amount, currency].join('|')
       end
 
       def split_authorization(authorization)

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

@@ -219,8 +219,7 @@ module ActiveMerchant #:nodoc:
         params[:MerchantID] = @options[:login]
         params[:RegKey] = @options[:password]
 
-        request = params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
-        request
+        params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def add_pair(post, key, value, options = {})

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

@@ -438,29 +438,21 @@ module ActiveMerchant #:nodoc:
       end
 
       # -- request methods ---------------------------------------------------
-      def build_xml_transaction_request
-        build_xml_request('SendTranRequest') do |doc|
-          yield doc
-        end
+      def build_xml_transaction_request(&block)
+        build_xml_request('SendTranRequest', &block)
       end
 
-      def build_xml_payment_storage_request
-        build_xml_request('UpdtRecurrProfRequest') do |doc|
-          yield doc
-        end
+      def build_xml_payment_storage_request(&block)
+        build_xml_request('UpdtRecurrProfRequest', &block)
       end
 
-      def build_xml_payment_update_request
+      def build_xml_payment_update_request(&block)
         merchant_product_type = 5 # credit card
-        build_xml_request('UpdtRecurrProfRequest', merchant_product_type) do |doc|
-          yield doc
-        end
+        build_xml_request('UpdtRecurrProfRequest', merchant_product_type, &block)
       end
 
-      def build_xml_payment_search_request
-        build_xml_request('FndRecurrProfRequest') do |doc|
-          yield doc
-        end
+      def build_xml_payment_search_request(&block)
+        build_xml_request('FndRecurrProfRequest', &block)
       end
 
       def build_xml_request(wrapper, merchant_product_type = nil)

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

@@ -172,7 +172,7 @@ module ActiveMerchant #:nodoc:
             { status: 'success', id: m[2] } :
             { status: 'failure', message: m[2] }
         else
-          Hash[status: body]
+          { status: body }
         end
       end
 

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

@@ -450,11 +450,15 @@ module ActiveMerchant #:nodoc:
         # to be considered successful, transaction status must be either "approved" or "accepted"
         success = SUCCESS_TYPES.include?(data['status'])
         message = message_from(data)
-        Response.new(success, message, data,
+        Response.new(
+          success,
+          message,
+          data,
           test: test?,
           authorization: authorization_from(action, data),
           cvv_result: data['cvv'],
-          avs_result: { code: data['avs'] })
+          avs_result: { code: data['avs'] }
+        )
       end
 
       def parse(body)

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

@@ -1030,15 +1030,17 @@ module ActiveMerchant #:nodoc:
 
       # Build soap header, etc.
       def build_request(action, options = {})
-        soap = Builder::XmlMarkup.new
-        soap.instruct!(:xml, version: '1.0', encoding: 'utf-8')
-        soap.tag! 'SOAP-ENV:Envelope',
+        envelope_obj = {
           'xmlns:SOAP-ENV' => 'http://schemas.xmlsoap.org/soap/envelope/',
           'xmlns:ns1' => 'urn:usaepay',
           'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
           'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
           'xmlns:SOAP-ENC' => 'http://schemas.xmlsoap.org/soap/encoding/',
-          'SOAP-ENV:encodingStyle' => 'http://schemas.xmlsoap.org/soap/encoding/' do
+          'SOAP-ENV:encodingStyle' => 'http://schemas.xmlsoap.org/soap/encoding/'
+        }
+        soap = Builder::XmlMarkup.new
+        soap.instruct!(:xml, version: '1.0', encoding: 'utf-8')
+        soap.tag! 'SOAP-ENV:Envelope', envelope_obj do
           soap.tag! 'SOAP-ENV:Body' do
             send("build_#{action}", soap, options)
           end
@@ -1335,8 +1337,7 @@ module ActiveMerchant #:nodoc:
         case
         when payment_method[:method].kind_of?(ActiveMerchant::Billing::CreditCard)
           build_tag soap, :string, 'CardNumber', payment_method[:method].number
-          build_tag soap, :string, 'CardExpiration',
-            "#{'%02d' % payment_method[:method].month}#{payment_method[:method].year.to_s[-2..-1]}"
+          build_tag soap, :string, 'CardExpiration', "#{'%02d' % payment_method[:method].month}#{payment_method[:method].year.to_s[-2..-1]}"
           if options[:billing_address]
             build_tag soap, :string, 'AvsStreet', options[:billing_address][:address1]
             build_tag soap, :string, 'AvsZip', options[:billing_address][:zip]
@@ -1520,8 +1521,8 @@ module ActiveMerchant #:nodoc:
 
         begin
           soap = ssl_post(url, request, 'Content-Type' => 'text/xml')
-        rescue ActiveMerchant::ResponseError => error
-          soap = error.response.body
+        rescue ActiveMerchant::ResponseError => e
+          soap = e.response.body
         end
 
         build_response(action, soap)

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

@@ -329,12 +329,16 @@ module ActiveMerchant #:nodoc:
         approved = response[:status] == 'Approved'
         error_code = nil
         error_code = (STANDARD_ERROR_CODE_MAPPING[response[:error_code]] || STANDARD_ERROR_CODE[:processing_error]) unless approved
-        Response.new(approved, message_from(response), response,
+        Response.new(
+          approved,
+          message_from(response),
+          response,
           test: test?,
           authorization: authorization_from(action, response),
           cvv_result: response[:cvv2_result_code],
           avs_result: { code: response[:avs_result_code] },
-          error_code: error_code)
+          error_code: error_code
+        )
       end
 
       def message_from(response)

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

@@ -281,11 +281,9 @@ module ActiveMerchant
         end
       end
 
-      def build_xml_request
+      def build_xml_request(&block)
         builder = Nokogiri::XML::Builder.new
-        builder.__send__('VancoWS') do |doc|
-          yield(doc)
-        end
+        builder.__send__('VancoWS', &block)
         builder.to_xml
       end