swiss-crm-activemerchant 1.0.12

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

@@ -0,0 +1,370 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class AirwallexGateway < Gateway
+      self.test_url = 'https://api-demo.airwallex.com/api/v1'
+      self.live_url = 'https://pci-api.airwallex.com/api/v1'
+
+      # per https://www.airwallex.com/docs/online-payments__overview, cards are accepted in all EU countries
+      self.supported_countries = %w[AT AU BE BG CY CZ DE DK EE GR ES FI FR GB HK HR HU IE IT LT LU LV MT NL PL PT RO SE SG SI SK]
+      self.default_currency = 'AUD'
+      self.supported_cardtypes = %i[visa master]
+
+      self.homepage_url = 'https://airwallex.com/'
+      self.display_name = 'Airwallex'
+
+      ENDPOINTS = {
+        login: '/authentication/login',
+        setup: '/pa/payment_intents/create',
+        sale: '/pa/payment_intents/%{id}/confirm',
+        capture: '/pa/payment_intents/%{id}/capture',
+        refund: '/pa/refunds/create',
+        void: '/pa/payment_intents/%{id}/cancel'
+      }
+
+      # Provided by Airwallex for testing purposes
+      TEST_NETWORK_TRANSACTION_IDS = {
+        visa: '123456789012345',
+        master: 'MCC123ABC0101'
+      }
+
+      def initialize(options = {})
+        requires!(options, :client_id, :client_api_key)
+        @client_id = options[:client_id]
+        @client_api_key = options[:client_api_key]
+        super
+        @access_token = setup_access_token
+      end
+
+      def purchase(money, card, options = {})
+        payment_intent_id = create_payment_intent(money, options)
+        post = {
+          'request_id' => request_id(options),
+          'merchant_order_id' => merchant_order_id(options)
+        }
+        add_card(post, card, options)
+        add_descriptor(post, options)
+        add_stored_credential(post, options)
+        add_return_url(post, options)
+        post['payment_method_options'] = { 'card' => { 'auto_capture' => false } } if authorization_only?(options)
+
+        add_three_ds(post, options)
+        commit(:sale, post, payment_intent_id)
+      end
+
+      def authorize(money, payment, options = {})
+        # authorize is just a purchase w/o an auto capture
+        purchase(money, payment, options.merge({ auto_capture: false }))
+      end
+
+      def capture(money, authorization, options = {})
+        raise ArgumentError, 'An authorization value must be provided.' if authorization.blank?
+
+        post = {
+          'request_id' => request_id(options),
+          'merchant_order_id' => merchant_order_id(options),
+          'amount' => amount(money)
+        }
+        add_descriptor(post, options)
+
+        commit(:capture, post, authorization)
+      end
+
+      def refund(money, authorization, options = {})
+        raise ArgumentError, 'An authorization value must be provided.' if authorization.blank?
+
+        post = {}
+        post[:amount] = amount(money)
+        post[:payment_intent_id] = authorization
+        post[:request_id] = request_id(options)
+        post[:merchant_order_id] = merchant_order_id(options)
+
+        commit(:refund, post)
+      end
+
+      def void(authorization, options = {})
+        raise ArgumentError, 'An authorization value must be provided.' if authorization.blank?
+
+        post = {}
+        post[:request_id] = request_id(options)
+        post[:merchant_order_id] = merchant_order_id(options)
+        add_descriptor(post, options)
+
+        commit(:void, post, authorization)
+      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(/(\\\"number\\\":\\\")\d+/, '\1[REDACTED]').
+          gsub(/(\\\"cvc\\\":\\\")\d+/, '\1[REDACTED]')
+      end
+
+      private
+
+      def request_id(options)
+        options[:request_id] || generate_uuid
+      end
+
+      def merchant_order_id(options)
+        options[:merchant_order_id] || options[:order_id] || generate_uuid
+      end
+
+      def add_return_url(post, options)
+        post[:return_url] = options[:return_url] if options[:return_url]
+      end
+
+      def generate_uuid
+        SecureRandom.uuid
+      end
+
+      def setup_access_token
+        token_headers = {
+          'Content-Type' => 'application/json',
+          'x-client-id' => @client_id,
+          'x-api-key' => @client_api_key
+        }
+        response = ssl_post(build_request_url(:login), nil, token_headers)
+        JSON.parse(response)['token']
+      end
+
+      def build_request_url(action, id = nil)
+        base_url = (test? ? test_url : live_url)
+        base_url + ENDPOINTS[action].to_s % { id: id }
+      end
+
+      def add_referrer_data(post)
+        post[:referrer_data] = { type: 'spreedly' }
+      end
+
+      def create_payment_intent(money, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_order(post, options)
+        post[:request_id] = "#{request_id(options)}_setup"
+        post[:merchant_order_id] = merchant_order_id(options)
+        add_referrer_data(post)
+        add_descriptor(post, options)
+        post['payment_method_options'] = { 'card' => { 'risk_control' => { 'three_ds_action' => 'SKIP_3DS' } } } if options[:skip_3ds]
+
+        response = commit(:setup, post)
+        raise ArgumentError.new(response.message) unless response.success?
+
+        response.params['id']
+      end
+
+      def add_billing(post, card, options = {})
+        return unless has_name_info?(card)
+
+        billing = post['payment_method']['card']['billing'] || {}
+        billing['email'] = options[:email] if options[:email]
+        billing['phone'] = options[:phone] if options[:phone]
+        billing['first_name'] = card.first_name
+        billing['last_name'] = card.last_name
+        billing_address = options[:billing_address]
+        billing['address'] = build_address(billing_address) if has_required_address_info?(billing_address)
+
+        post['payment_method']['card']['billing'] = billing
+      end
+
+      def has_name_info?(card)
+        # These fields are required if billing data is sent.
+        card.first_name && card.last_name
+      end
+
+      def has_required_address_info?(address)
+        # These fields are required if address data is sent.
+        return unless address
+
+        address[:address1] && address[:country]
+      end
+
+      def build_address(address)
+        return unless address
+
+        address_data = {} # names r hard
+        address_data[:country_code] = address[:country]
+        address_data[:street] = address[:address1]
+        address_data[:city] = address[:city] if address[:city] # required per doc, not in practice
+        address_data[:postcode] = address[:zip] if address[:zip]
+        address_data[:state] = address[:state] if address[:state]
+        address_data
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+      end
+
+      def add_card(post, card, options = {})
+        post['payment_method'] = {
+          'type' => 'card',
+          'card' => {
+            'expiry_month' => format(card.month, :two_digits),
+            'expiry_year' => card.year.to_s,
+            'number' => card.number.to_s,
+            'name' => card.name,
+            'cvc' => card.verification_value,
+            'brand' => card.brand
+          }
+        }
+        add_billing(post, card, options)
+      end
+
+      def add_order(post, options)
+        return unless shipping_address = options[:shipping_address]
+
+        physical_address = build_shipping_address(shipping_address)
+        first_name, last_name = split_names(shipping_address[:name])
+        shipping = {}
+        shipping[:first_name] = first_name if first_name
+        shipping[:last_name] = last_name if last_name
+        shipping[:phone_number] = shipping_address[:phone_number] if shipping_address[:phone_number]
+        shipping[:address] = physical_address
+        post[:order] = { shipping: shipping }
+      end
+
+      def build_shipping_address(shipping_address)
+        address = {}
+        address[:city] = shipping_address[:city]
+        address[:country_code] = shipping_address[:country]
+        address[:postcode] = shipping_address[:zip]
+        address[:state] = shipping_address[:state]
+        address[:street] = shipping_address[:address1]
+        address
+      end
+
+      def add_stored_credential(post, options)
+        return unless stored_credential = options[:stored_credential]
+
+        external_recurring_data = post[:external_recurring_data] = {}
+
+        case stored_credential.dig(:reason_type)
+        when 'recurring', 'installment'
+          external_recurring_data[:merchant_trigger_reason] = 'scheduled'
+        when 'unscheduled'
+          external_recurring_data[:merchant_trigger_reason] = 'unscheduled'
+        end
+
+        external_recurring_data[:original_transaction_id] = test_mit?(options) ? test_network_transaction_id(post) : stored_credential.dig(:network_transaction_id)
+        external_recurring_data[:triggered_by] = stored_credential.dig(:initiator) == 'cardholder' ? 'customer' : 'merchant'
+      end
+
+      def test_network_transaction_id(post)
+        case post['payment_method']['card']['brand']
+        when 'visa'
+          TEST_NETWORK_TRANSACTION_IDS[:visa]
+        when 'master'
+          TEST_NETWORK_TRANSACTION_IDS[:master]
+        end
+      end
+
+      def test_mit?(options)
+        test? && options.dig(:stored_credential, :initiator) == 'merchant'
+      end
+
+      def add_three_ds(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        pm_options = post.dig('payment_method_options', 'card')
+
+        external_three_ds = {
+          'version': format_three_ds_version(three_d_secure),
+          'eci': three_d_secure[:eci]
+        }.merge(three_ds_version_specific_fields(three_d_secure))
+
+        pm_options ? pm_options.merge!('external_three_ds': external_three_ds) : post['payment_method_options'] = { 'card': { 'external_three_ds': external_three_ds } }
+      end
+
+      def format_three_ds_version(three_d_secure)
+        version = three_d_secure[:version].split('.')
+
+        version.push('0') until version.length == 3
+        version.join('.')
+      end
+
+      def three_ds_version_specific_fields(three_d_secure)
+        if three_d_secure[:version].to_f >= 2
+          {
+            'authentication_value': three_d_secure[:cavv],
+            'ds_transaction_id': three_d_secure[:ds_transaction_id],
+            'three_ds_server_transaction_id': three_d_secure[:three_ds_server_trans_id]
+          }
+        else
+          {
+            'cavv': three_d_secure[:cavv],
+            'xid': three_d_secure[:xid]
+          }
+        end
+      end
+
+      def authorization_only?(options = {})
+        options.include?(:auto_capture) && options[:auto_capture] == false
+      end
+
+      def add_descriptor(post, options)
+        post[:descriptor] = options[:description] if options[:description]
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, post, id = nil)
+        url = build_request_url(action, id)
+
+        post_headers = { 'Authorization' => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+        response = parse(ssl_post(url, post_data(post), post_headers))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: response.dig('latest_payment_attempt', 'authentication_data', 'avs_result')),
+          cvv_result: CVVResult.new(response.dig('latest_payment_attempt', 'authentication_data', 'cvc_code')),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300, 400, 404
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
+      def post_data(post)
+        post.to_json
+      end
+
+      def success_from(response)
+        %w(REQUIRES_PAYMENT_METHOD SUCCEEDED RECEIVED REQUIRES_CAPTURE CANCELLED).include?(response['status'])
+      end
+
+      def message_from(response)
+        response.dig('latest_payment_attempt', 'status') || response['status'] || response['message']
+      end
+
+      def authorization_from(response)
+        response.dig('latest_payment_attempt', 'payment_intent_id')
+      end
+
+      def error_code_from(response)
+        response['provider_original_response_code'] || response['code'] unless success_from(response)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+require 'jose'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class AleloGateway < Gateway
+      class_attribute :prelive_url
+
+      self.test_url = 'https://sandbox-api.alelo.com.br/alelo/sandbox/'
+      self.live_url = 'https://api.alelo.com.br/alelo/prd/'
+      self.prelive_url = 'https://api.homologacaoalelo.com.br/alelo/uat/'
+
+      self.supported_countries = ['BR']
+      self.default_currency = 'BRL'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://www.alelo.com.br'
+      self.display_name = 'Alelo'
+
+      def initialize(options = {})
+        requires!(options, :client_id, :client_secret)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_order(post, options)
+        add_amount(post, money)
+        add_payment(post, payment)
+        add_geolocation(post, options)
+        add_extra_data(post, options)
+
+        commit('capture/transaction', post, options)
+      end
+
+      def refund(money, authorization, options = {})
+        request_id = authorization.split('#').first
+        options[:http] = { method: :put, prevent_encrypt: true }
+        commit('capture/transaction/refund', { requestId: request_id }, options, :put)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        force_utf8(transcript.encode).
+          gsub(%r((Authorization: Bearer )[\w -]+), '\1[FILTERED]').
+          gsub(%r((client_id=|Client-Id:)[\w -]+), '\1[FILTERED]\2').
+          gsub(%r((client_secret=|Client-Secret:)[\w -]+), '\1[FILTERED]\2').
+          gsub(%r((access_token\":\")[^\"]*), '\1[FILTERED]').
+          gsub(%r((publicKey\":\")[^\"]*), '\1[FILTERED]')
+      end
+
+      private
+
+      def force_utf8(string)
+        return nil unless string
+
+        # binary = string.encode('BINARY', invalid: :replace, undef: :replace, replace: '?')
+        string.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+      end
+
+      def add_amount(post, money)
+        post[:amount] = amount(money).to_f
+      end
+
+      def add_order(post, options)
+        post[:requestId] = options[:order_id]
+      end
+
+      def add_extra_data(post, options)
+        post.merge!({
+          establishmentCode: options[:establishment_code],
+          playerIdentification: options[:player_identification],
+          captureType: '3', # send fixed value 3 to ecommerce
+          subMerchantCode: options[:sub_merchant_mcc],
+          externalTraceNumber: options[:external_trace_number]
+        }.compact)
+      end
+
+      def add_geolocation(post, options)
+        return if options[:geo_latitude].blank? || options[:geo_longitude].blank?
+
+        post.merge!(geolocation: {
+          latitude: options[:geo_latitude],
+          longitude: options[:geo_longitude]
+        })
+      end
+
+      def add_payment(post, payment)
+        post.merge!({
+          cardNumber: payment.number,
+          cardholderName: payment.name,
+          expirationMonth: payment.month,
+          expirationYear: format(payment.year, :two_digits).to_i,
+          securityCode: payment.verification_value
+        })
+      end
+
+      def fetch_access_token
+        params = {
+          grant_type: 'client_credentials',
+          client_id: @options[:client_id],
+          client_secret: @options[:client_secret],
+          scope: '/capture'
+        }
+
+        headers = {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/x-www-form-urlencoded'
+        }
+
+        parsed = parse(ssl_post(url('captura-oauth-provider/oauth/token'), post_data(params), headers))
+        Response.new(true, parsed[:access_token], parsed)
+      end
+
+      def remote_encryption_key(access_token)
+        response = parse(ssl_get(url('capture/key'), request_headers(access_token)))
+        Response.new(true, response[:publicKey], response)
+      end
+
+      def ensure_credentials(try_again = true)
+        multiresp = MultiResponse.new
+        access_token = @options[:access_token]
+        key = @options[:encryption_key]
+        uuid = @options[:encryption_uuid]
+
+        if access_token.blank?
+          multiresp.process { fetch_access_token }
+          access_token = multiresp.message
+          key = nil
+          uuid = nil
+        end
+
+        if key.blank?
+          multiresp.process { remote_encryption_key(access_token) }
+          key = multiresp.message
+          uuid = multiresp.params['uuid']
+        end
+
+        {
+          key: key,
+          uuid: uuid,
+          access_token: access_token,
+          multiresp: multiresp.responses.present? ? multiresp : nil
+        }
+      rescue ResponseError => error
+        # retry to generate a new access_token when the provided one is expired
+        raise error unless try_again && %w(401 404).include?(error.response.code) && @options[:access_token].present?
+
+        @options.delete(:access_token)
+        @options.delete(:encryption_key)
+        ensure_credentials false
+      end
+
+      def encrypt_payload(body, credentials, options)
+        key = OpenSSL::PKey::RSA.new(Base64.decode64(credentials[:key]))
+        jwk = JOSE::JWK.from_key(key)
+        alg_enc = { 'alg' => 'RSA-OAEP-256', 'enc' => 'A128CBC-HS256' }
+
+        token = JOSE::JWE.block_encrypt(jwk, body.to_json, alg_enc).compact
+
+        encrypted_body = {
+          token: token,
+          uuid: credentials[:uuid]
+        }
+
+        encrypted_body.to_json
+      end
+
+      def parse(body)
+        JSON.parse(body, symbolize_names: true)
+      end
+
+      def post_data(params)
+        params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def commit(action, body, options, try_again = true)
+        credentials = ensure_credentials
+        payload = encrypt_payload(body, credentials, options)
+
+        if options.dig :http, :method
+          payload = body.to_json if options.dig :http, :prevent_encrypt
+          response = parse ssl_request(options[:http][:method], url(action), payload, request_headers(credentials[:access_token]))
+        else
+          response = parse ssl_post(url(action), payload, request_headers(credentials[:access_token]))
+        end
+
+        resp = Response.new(
+          success_from(action, response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, options),
+          test: test?
+        )
+
+        return resp unless credentials[:multiresp].present?
+
+        multiresp = credentials[:multiresp]
+        resp.params.merge!({
+          'access_token' => credentials[:access_token],
+          'encryption_key' => credentials[:key],
+          'encryption_uuid' => credentials[:uuid]
+        })
+        multiresp.process { resp }
+
+        multiresp
+      rescue ActiveMerchant::ResponseError => e
+        # Retry on a possible expired encryption key
+        if try_again && %w(401 404).include?(e.response.code) && @options[:encryption_key].present?
+          @options.delete(:encryption_key)
+          commit(action, body, options, false)
+        else
+          res = parse(e.response.body)
+          Response.new(false, res[:messageUser] || res[:error], res, test: test?)
+        end
+      end
+
+      def success_from(action, response)
+        case action
+        when 'capture/transaction/refund'
+          response[:status] == 'ESTORNADA'
+        when 'capture/transaction'
+          response[:status] == 'CONFIRMADA'
+        else
+          false
+        end
+      end
+
+      def message_from(response)
+        response[:messages] || response[:messageUser]
+      end
+
+      def authorization_from(response, options)
+        [response[:requestId]].join('#')
+      end
+
+      def url(action)
+        return prelive_url if @options[:url_override] == 'prelive'
+
+        "#{test? ? test_url : live_url}#{action}"
+      end
+
+      def request_headers(access_token)
+        {
+          'Accept' => 'application/json',
+          'X-IBM-Client-Id' => @options[:client_id],
+          'X-IBM-Client-Secret' => @options[:client_secret],
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{access_token}"
+        }
+      end
+    end
+  end
+end