activemerchant 1.117.0 → 1.123.0

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

@@ -33,7 +33,7 @@ module ActiveMerchant #:nodoc:
         add_creator_info(post, options)
         add_fraud_fields(post, options)
         add_external_cardholder_authentication_data(post, options)
-        commit(:authorize, post)
+        commit(:authorize, post, options: options)
       end
 
       def capture(money, authorization, options = {})
@@ -41,7 +41,7 @@ module ActiveMerchant #:nodoc:
         add_order(post, money, options, capture: true)
         add_customer_data(post, options)
         add_creator_info(post, options)
-        commit(:capture, post, authorization)
+        commit(:capture, post, authorization: authorization)
       end
 
       def refund(money, authorization, options = {})
@@ -49,13 +49,13 @@ module ActiveMerchant #:nodoc:
         add_amount(post, money, options)
         add_refund_customer_data(post, options)
         add_creator_info(post, options)
-        commit(:refund, post, authorization)
+        commit(:refund, post, authorization: authorization)
       end
 
       def void(authorization, options = {})
         post = nestable_hash
         add_creator_info(post, options)
-        commit(:void, post, authorization)
+        commit(:void, post, authorization: authorization)
       end
 
       def verify(payment, options = {})
@@ -201,21 +201,21 @@ module ActiveMerchant #:nodoc:
         shipping_address = options[:shipping_address]
         if billing_address = options[:billing_address] || options[:address]
           post['order']['customer']['billingAddress'] = {
-            'street' => billing_address[:address1],
-            'additionalInfo' => billing_address[:address2],
+            'street' => truncate(billing_address[:address1], 50),
+            'additionalInfo' => truncate(billing_address[:address2], 50),
             'zip' => billing_address[:zip],
             'city' => billing_address[:city],
-            'state' => billing_address[:state],
+            'state' => truncate(billing_address[:state], 35),
             'countryCode' => billing_address[:country]
           }
         end
         if shipping_address
           post['order']['customer']['shippingAddress'] = {
-            'street' => shipping_address[:address1],
-            'additionalInfo' => shipping_address[:address2],
+            'street' => truncate(shipping_address[:address1], 50),
+            'additionalInfo' => truncate(shipping_address[:address2], 50),
             'zip' => shipping_address[:zip],
             'city' => shipping_address[:city],
-            'state' => shipping_address[:state],
+            'state' => truncate(shipping_address[:state], 35),
             'countryCode' => shipping_address[:country]
           }
           post['order']['customer']['shippingAddress']['name'] = {
@@ -277,9 +277,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def commit(action, post, authorization = nil)
+      def idempotency_key_for_signature(options)
+        "x-gcs-idempotence-key:#{options[:idempotency_key]}" if options[:idempotency_key]
+      end
+
+      def commit(action, post, authorization: nil, options: {})
         begin
-          raw_response = ssl_post(url(action, authorization), post.to_json, headers(action, post, authorization))
+          raw_response = ssl_post(url(action, authorization), post.to_json, headers(action, post, authorization, options))
           response = parse(raw_response)
         rescue ResponseError => e
           response = parse(e.response.body) if e.response.code.to_i >= 400
@@ -306,21 +310,26 @@ module ActiveMerchant #:nodoc:
         }
       end
 
-      def headers(action, post, authorization = nil)
-        {
+      def headers(action, post, authorization = nil, options = {})
+        headers = {
           'Content-Type' => content_type,
-          'Authorization' => auth_digest(action, post, authorization),
+          'Authorization' => auth_digest(action, post, authorization, options),
           'Date' => date
         }
+
+        headers['X-GCS-Idempotence-Key'] = options[:idempotency_key] if options[:idempotency_key]
+        headers
       end
 
-      def auth_digest(action, post, authorization = nil)
+      def auth_digest(action, post, authorization = nil, options = {})
         data = <<~REQUEST
           POST
           #{content_type}
           #{date}
+          #{idempotency_key_for_signature(options)}
           #{uri(action, authorization)}
         REQUEST
+        data = data.each_line.reject { |line| line.strip == '' }.join
         digest = OpenSSL::Digest.new('sha256')
         key = @options[:secret_api_key]
         "GCS v1HMAC:#{@options[:api_key_id]}:#{Base64.strict_encode64(OpenSSL::HMAC.digest(digest, key, data))}"

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

@@ -39,6 +39,7 @@ module ActiveMerchant #:nodoc:
           add_descriptor_name(xml, options)
           add_card_or_token_payment(xml, card_or_token, options)
           add_three_d_secure(xml, card_or_token, options)
+          add_stored_credentials(xml, options)
         end
       end
 
@@ -52,6 +53,8 @@ module ActiveMerchant #:nodoc:
       def purchase(money, payment_method, options = {})
         if payment_method.is_a?(Check)
           commit_check_sale(money, payment_method, options)
+        elsif options.dig(:stored_credential, :reason_type) == 'recurring'
+          commit_recurring_billing_sale(money, payment_method, options)
         else
           commit_credit_sale(money, payment_method, options)
         end
@@ -67,6 +70,15 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def credit(money, payment_method, options = {})
+        commit('CreditReturn') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_card_or_token_payment(xml, payment_method, options)
+          add_details(xml, options)
+        end
+      end
+
       def verify(card_or_token, options = {})
         commit('CreditAccountVerify') do |xml|
           add_card_or_token_customer_data(xml, card_or_token, options)
@@ -122,6 +134,21 @@ module ActiveMerchant #:nodoc:
           add_descriptor_name(xml, options)
           add_card_or_token_payment(xml, card_or_token, options)
           add_three_d_secure(xml, card_or_token, options)
+          add_stored_credentials(xml, options)
+        end
+      end
+
+      def commit_recurring_billing_sale(money, card_or_token, options)
+        commit('RecurringBilling') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_card_or_token_customer_data(xml, card_or_token, options)
+          add_details(xml, options)
+          add_descriptor_name(xml, options)
+          add_card_or_token_payment(xml, card_or_token, options)
+          add_three_d_secure(xml, card_or_token, options)
+          add_stored_credentials(xml, options)
+          add_stored_credentials_for_recurring_billing(xml, options)
         end
       end
 
@@ -148,7 +175,7 @@ module ActiveMerchant #:nodoc:
             xml.hps :CardHolderAddr, billing_address[:address1] if billing_address[:address1]
             xml.hps :CardHolderCity, billing_address[:city] if billing_address[:city]
             xml.hps :CardHolderState, billing_address[:state] if billing_address[:state]
-            xml.hps :CardHolderZip, billing_address[:zip] if billing_address[:zip]
+            xml.hps :CardHolderZip, alphanumeric_zip(billing_address[:zip]) if billing_address[:zip]
           end
         end
       end
@@ -210,7 +237,7 @@ module ActiveMerchant #:nodoc:
       def add_details(xml, options)
         xml.hps :AdditionalTxnFields do
           xml.hps :Description, options[:description] if options[:description]
-          xml.hps :InvoiceNbr, options[:order_id] if options[:order_id]
+          xml.hps :InvoiceNbr, options[:order_id][0..59] if options[:order_id]
           xml.hps :CustomerID, options[:customer_id] if options[:customer_id]
         end
       end
@@ -256,6 +283,38 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      # We do not currently support installments on this gateway.
+      # The HPS gateway treats recurring transactions as a seperate transaction type
+      def add_stored_credentials(xml, options)
+        return unless options[:stored_credential]
+
+        xml.hps :CardOnFileData do
+          if options[:stored_credential][:initiator] == 'customer'
+            xml.hps :CardOnFile, 'C'
+          elsif options[:stored_credential][:initiator] == 'merchant'
+            xml.hps :CardOnFile, 'M'
+          else
+            return
+          end
+
+          if options[:stored_credential][:network_transaction_id]
+            xml.hps :CardBrandTxnId, options[:stored_credential][:network_transaction_id]
+          else
+            return
+          end
+        end
+      end
+
+      def add_stored_credentials_for_recurring_billing(xml, options)
+        xml.hps :RecurringData do
+          if options[:stored_credential][:reason_type] = 'recurring'
+            xml.hps :OneTime, 'N'
+          else
+            xml.hps :OneTime, 'Y'
+          end
+        end
+      end
+
       def strip_leading_zero(value)
         return value unless value[0] == '0'
 
@@ -380,6 +439,10 @@ module ActiveMerchant #:nodoc:
         @options[:secret_api_key]&.include?('_cert_')
       end
 
+      def alphanumeric_zip(zip)
+        zip.gsub(/[^0-9a-z]/i, '')
+      end
+
       ISSUER_MESSAGES = {
         '13' => 'Must be greater than or equal 0.',
         '14' => 'The card number is incorrect.',

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

@@ -37,6 +37,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         post[:ticketNumber] = authorization
         add_invoice(action, post, amount, options)
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -46,6 +47,7 @@ module ActiveMerchant #:nodoc:
 
         post = {}
         post[:ticketNumber] = authorization
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -55,6 +57,7 @@ module ActiveMerchant #:nodoc:
 
         post = {}
         post[:ticketNumber] = authorization
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -78,6 +81,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_invoice(action, post, amount, options)
         add_payment_method(post, payment_method, options)
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -88,6 +92,8 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_reference(post, authorization, options)
         add_invoice(action, post, amount, options)
+        add_contact_details(post, options[:contact_details]) if options[:contact_details]
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -98,6 +104,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_reference(post, authorization, options)
         add_invoice(action, post, amount, options)
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -154,6 +161,22 @@ module ActiveMerchant #:nodoc:
         post[:token] = authorization
       end
 
+      def add_contact_details(post, contact_details_options)
+        contact_details = {}
+        contact_details[:documentType] = contact_details_options[:document_type] if contact_details_options[:document_type]
+        contact_details[:documentNumber] = contact_details_options[:document_number] if contact_details_options[:document_number]
+        contact_details[:email] = contact_details_options[:email] if contact_details_options[:email]
+        contact_details[:firstName] = contact_details_options[:first_name] if contact_details_options[:first_name]
+        contact_details[:lastName] = contact_details_options[:last_name] if contact_details_options[:last_name]
+        contact_details[:secondLastName] = contact_details_options[:second_last_name] if contact_details_options[:second_last_name]
+        contact_details[:phoneNumber] = contact_details_options[:phone_number] if contact_details_options[:phone_number]
+        post[:contactDetails] = contact_details
+      end
+
+      def add_full_response(post, options)
+        post[:fullResponse] = options[:full_response].to_s.casecmp('true').zero? if options[:full_response]
+      end
+
       ENDPOINT = {
         'tokenize' => 'tokens',
         'charge' => 'charges',

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

@@ -5,7 +5,10 @@ module ActiveMerchant #:nodoc:
     class LitleGateway < Gateway
       SCHEMA_VERSION = '9.14'
 
+      class_attribute :postlive_url
+
       self.test_url = 'https://www.testvantivcnp.com/sandbox/communicator/online'
+      self.postlive_url = 'https://payments.vantivpostlive.com/vap/communicator/online'
       self.live_url = 'https://payments.vantivcnp.com/vap/communicator/online'
 
       self.supported_countries = ['US']
@@ -368,9 +371,9 @@ module ActiveMerchant #:nodoc:
         return unless address
 
         doc.companyName(address[:company]) unless address[:company].blank?
-        doc.addressLine1(address[:address1]) unless address[:address1].blank?
-        doc.addressLine2(address[:address2]) unless address[:address2].blank?
-        doc.city(address[:city]) unless address[:city].blank?
+        doc.addressLine1(truncate(address[:address1], 35)) unless address[:address1].blank?
+        doc.addressLine2(truncate(address[:address2], 35)) unless address[:address2].blank?
+        doc.city(truncate(address[:city], 35)) unless address[:city].blank?
         doc.state(address[:state]) unless address[:state].blank?
         doc.zip(address[:zip]) unless address[:zip].blank?
         doc.country(address[:country]) unless address[:country].blank?
@@ -491,7 +494,7 @@ module ActiveMerchant #:nodoc:
         attributes = {}
         attributes[:id] = truncate(options[:id] || options[:order_id], 24)
         attributes[:reportGroup] = options[:merchant] || 'Default Report Group'
-        attributes[:customerId] = options[:customer]
+        attributes[:customerId] = options[:customer_id]
         attributes.delete_if { |_key, value| value == nil }
         attributes
       end
@@ -513,6 +516,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def url
+        return postlive_url if @options[:url_override].to_s == 'postlive'
+
         test? ? test_url : live_url
       end
 

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

@@ -4,7 +4,7 @@ module ActiveMerchant #:nodoc:
       self.live_url = self.test_url = 'https://api.mercadopago.com/v1'
 
       self.supported_countries = %w[AR BR CL CO MX PE UY]
-      self.supported_cardtypes = %i[visa master american_express elo cabal naranja]
+      self.supported_cardtypes = %i[visa master american_express elo cabal naranja creditel]
 
       self.homepage_url = 'https://www.mercadopago.com/'
       self.display_name = 'Mercado Pago'
@@ -105,7 +105,7 @@ module ActiveMerchant #:nodoc:
 
       def authorize_request(money, payment, options = {})
         post = purchase_request(money, payment, options)
-        post[:capture] = false
+        post[:capture] = options[:capture] || false
         post
       end
 
@@ -129,6 +129,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]
@@ -143,7 +144,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)
@@ -191,7 +192,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)

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

@@ -187,6 +187,8 @@ module ActiveMerchant #:nodoc:
       def parse(body)
         xml = REXML::Document.new(body)
 
+        return { response_message: 'Invalid gateway response' } unless xml.root.present?
+
         response = {}
         xml.root.elements.to_a.each do |node|
           parse_element(response, node)

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

@@ -0,0 +1,277 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MokaGateway < Gateway
+      self.test_url = 'https://service.testmoka.com'
+      self.live_url = 'https://service.moka.com'
+
+      self.supported_countries = %w[GB TR US]
+      self.default_currency = 'TRY'
+      self.money_format = :dollars
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'http://developer.moka.com/'
+      self.display_name = 'Moka'
+
+      ERROR_CODE_MAPPING = {
+        '000' =>	'General error',
+        '001' =>	'3D Not authenticated',
+        '002' =>	'Limit is insufficient',
+        '003' =>	'Credit card number format is wrong',
+        '004' =>	'General decline',
+        '005' =>	'This process is invalid for the card owner',
+        '006' =>	'Expiration date is wrong',
+        '007' =>	'Invalid transaction',
+        '008' =>	'Connection with the bank not established',
+        '009' =>	'Undefined error code',
+        '010' =>	'Bank SSL error',
+        '011' =>	'Call the bank for the manual authentication',
+        '012' =>	'Card info is wrong - Kart Number or CVV2',
+        '013' =>	'3D secure is not supported other than Visa MC cards',
+        '014' =>	'Invalid account number',
+        '015' =>	'CVV is wrong',
+        '016' =>	'Authentication process is not present',
+        '017' =>	'System error',
+        '018' =>	'Stolen card',
+        '019' =>	'Lost card',
+        '020' =>	'Card with limited properties',
+        '021' =>	'Timeout',
+        '022' =>	'Invalid merchant',
+        '023' =>	'False authentication',
+        '024' =>	'3D authorization is successful but the process cannot be completed',
+        '025' =>	'3D authorization failure',
+        '026' =>	'Either the issuer bank or the card is not enrolled to the 3D process',
+        '027' =>	'The bank did not allow the process',
+        '028' =>	'Fraud suspect',
+        '029' =>	'The card is closed to the e-commerce operations'
+      }
+
+      def initialize(options = {})
+        requires!(options, :dealer_code, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        post[:PaymentDealerRequest] = {}
+        options[:pre_auth] = 0
+        add_auth_purchase(post, money, payment, options)
+
+        commit('purchase', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        post[:PaymentDealerRequest] = {}
+        options[:pre_auth] = 1
+        add_auth_purchase(post, money, payment, options)
+
+        commit('authorize', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:PaymentDealerRequest] = {}
+        add_payment_dealer_authentication(post)
+        add_transaction_reference(post, authorization)
+        add_additional_transaction_data(post, options)
+
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:PaymentDealerRequest] = {}
+        add_payment_dealer_authentication(post)
+        add_transaction_reference(post, authorization)
+        add_additional_transaction_data(post, options)
+        add_void_refund_reason(post)
+        add_amount(post, money)
+
+        commit('refund', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        post[:PaymentDealerRequest] = {}
+        add_payment_dealer_authentication(post)
+        add_transaction_reference(post, authorization)
+        add_additional_transaction_data(post, options)
+        add_void_refund_reason(post)
+
+        commit('void', 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(("CardNumber\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("CvcNumber\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("DealerCode\\?":\\?"?)[^"?]*)i, '\1[FILTERED]').
+          gsub(%r(("Username\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("Password\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("CheckKey\\?":\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def add_auth_purchase(post, money, payment, options)
+        add_payment_dealer_authentication(post)
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_additional_auth_purchase_data(post, options)
+        add_additional_transaction_data(post, options)
+        add_buyer_information(post, payment, options)
+        add_basket_product(post, options[:basket_product]) if options[:basket_product]
+      end
+
+      def add_payment_dealer_authentication(post)
+        post[:PaymentDealerAuthentication] = {
+          DealerCode: @options[:dealer_code],
+          Username: @options[:username],
+          Password: @options[:password],
+          CheckKey: check_key
+        }
+      end
+
+      def check_key
+        str = "#{@options[:dealer_code]}MK#{@options[:username]}PD#{@options[:password]}"
+        Digest::SHA256.hexdigest(str)
+      end
+
+      def add_invoice(post, money, options)
+        post[:PaymentDealerRequest][:Amount] = amount(money) || 0
+        post[:PaymentDealerRequest][:Currency] = options[:currency] || 'TL'
+      end
+
+      def add_payment(post, card)
+        post[:PaymentDealerRequest][:CardHolderFullName] = card.name
+        post[:PaymentDealerRequest][:CardNumber] = card.number
+        post[:PaymentDealerRequest][:ExpMonth] = card.month
+        post[:PaymentDealerRequest][:ExpYear] = card.year
+        post[:PaymentDealerRequest][:CvcNumber] = card.verification_value
+      end
+
+      def add_amount(post, money)
+        post[:PaymentDealerRequest][:Amount] = money || 0
+      end
+
+      def add_additional_auth_purchase_data(post, options)
+        post[:PaymentDealerRequest][:IsPreAuth] = options[:pre_auth]
+        post[:PaymentDealerRequest][:Description] = options[:order_id] if options[:order_id]
+        post[:SubMerchantName] = options[:sub_merchant_name] if options[:sub_merchant_name]
+        post[:IsPoolPayment] = options[:is_pool_payment] || 0
+      end
+
+      def add_buyer_information(post, card, options)
+        obj = {}
+
+        obj[:BuyerFullName] = card.name || ''
+        obj[:BuyerEmail] = options[:email] if options[:email]
+        obj[:BuyerAddress] = options[:billing_address][:address1] if options[:billing_address]
+        obj[:BuyerGsmNumber] = options[:billing_address][:phone] if options[:billing_address]
+
+        post[:PaymentDealerRequest][:BuyerInformation] = obj
+      end
+
+      def add_basket_product(post, basket_options)
+        basket = []
+
+        basket_options.each do |product|
+          obj = {}
+          obj[:ProductId] = product[:product_id] if product[:product_id]
+          obj[:ProductCode] = product[:product_code] if product[:product_code]
+          obj[:UnitPrice] = amount(product[:unit_price]) if product[:unit_price]
+          obj[:Quantity] = product[:quantity] if product[:quantity]
+          basket << obj
+        end
+
+        post[:PaymentDealerRequest][:BasketProduct] = basket
+      end
+
+      def add_additional_transaction_data(post, options)
+        post[:PaymentDealerRequest][:ClientIP] = options[:ip] if options[:ip]
+        post[:PaymentDealerRequest][:OtherTrxCode] = options[:order_id] if options[:order_id]
+      end
+
+      def add_transaction_reference(post, authorization)
+        post[:PaymentDealerRequest][:VirtualPosOrderId] = authorization
+      end
+
+      def add_void_refund_reason(post)
+        post[:PaymentDealerRequest][:VoidRefundReason] = 2
+      end
+
+      def commit(action, parameters)
+        response = parse(ssl_post(url(action), post_data(parameters), request_headers))
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def url(action)
+        host = (test? ? test_url : live_url)
+        endpoint = endpoint(action)
+
+        "#{host}/PaymentDealer/#{endpoint}"
+      end
+
+      def endpoint(action)
+        case action
+        when 'purchase', 'authorize'
+          'DoDirectPayment'
+        when 'capture'
+          'DoCapture'
+        when 'void'
+          'DoVoid'
+        when 'refund'
+          'DoCreateRefundRequest'
+        end
+      end
+
+      def request_headers
+        { 'Content-Type' => 'application/json' }
+      end
+
+      def post_data(parameters = {})
+        JSON.generate(parameters)
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        response.dig('Data', 'IsSuccessful')
+      end
+
+      def message_from(response)
+        response.dig('Data', 'ResultMessage').presence || response['ResultCode']
+      end
+
+      def authorization_from(response)
+        response.dig('Data', 'VirtualPosOrderId')
+      end
+
+      def error_code_from(response)
+        codes = [response['ResultCode'], response.dig('Data', 'ResultCode')].flatten
+        codes.reject! { |code| code.blank? || code.casecmp('success').zero? }
+        codes.map { |code| ERROR_CODE_MAPPING[code] || code }.join(', ')
+      end
+    end
+  end
+end