connect-sdk-ruby 2.47.1 → 3.0.0

data/lib/worldline/connect/sdk/v1/merchant.rb

@@ -0,0 +1,5 @@
+#
+# This file was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+Dir[File.join(__dir__, 'merchant', '*.rb')].each { |f| require f }

data/lib/worldline/connect/sdk/v1/platform_exception.rb

@@ -0,0 +1,26 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+require_relative 'api_exception'
+
+module Worldline
+  module Connect
+    module SDK
+      module V1
+        # This exception is thrown when a response from the Worldline Global Collect platform indicates that an error occurred
+        # on the Worldline Global Collect platform while processing the request.
+        # This corresponds to a HTTP status code of 500 or 502.
+        class PlatformException < ApiException
+
+          # Create a new PlatformException
+          # @see ApiException#initialize
+          def initialize(status_code, response_body, error_id, errors,
+                         message='the Worldline Global Collect platform returned an error response')
+            super(status_code, response_body, error_id, errors, message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/v1/reference_exception.rb

@@ -0,0 +1,25 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+require_relative 'api_exception'
+
+module Worldline
+  module Connect
+    module SDK
+      module V1
+        # This error is raised when the request refers to a resource or object that is not found by the Worldline Global Collect platform.
+        # The object referred to may not exist or it could have been removed recently.
+        class ReferenceException < ApiException
+
+          # Create a new ReferenceException.
+          # @see ApiException#initialize
+          def initialize(status_code, response_body, error_id, errors,
+                         message='the Worldline Global Collect platform returned a reference error response')
+            super(status_code, response_body, error_id, errors, message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/v1/v1_client.rb

@@ -0,0 +1,35 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+require 'worldline/connect/sdk/api_resource'
+require 'worldline/connect/sdk/v1/merchant/merchant_client'
+
+module Worldline
+  module Connect
+    module SDK
+      module V1
+        # V1 client.
+        #
+        # Thread safe.
+        class V1Client < Worldline::Connect::SDK::ApiResource
+
+          # @param parent       [Worldline::Connect::SDK::ApiResource]
+          # @param path_context [Hash, nil]
+          def initialize(parent, path_context)
+            super(parent: parent, path_context: path_context)
+          end
+
+          # Resource /!{merchantId}
+          # @param merchant_id [String]
+          # @return [Worldline::Connect::SDK::V1::Merchant::MerchantClient]
+          def merchant(merchant_id)
+            Worldline::Connect::SDK::V1::Merchant::MerchantClient.new(self, {
+              'merchantId'.freeze => merchant_id,
+            })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/v1/validation_exception.rb

@@ -0,0 +1,25 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+require_relative 'api_exception'
+
+module Worldline
+  module Connect
+    module SDK
+      module V1
+        # Raised when the request sent to the Worldline Global Collect platform returned a HTTP response with status code 400.
+        # This indicates the request received by the Worldline Global Collect platform was malformed.
+        class ValidationException < ApiException
+
+          # Create a new ValidationException
+          # @see ApiException#initialize
+          def initialize(status_code, response_body, error_id, errors,
+                         message='the Worldline Global Collect platform returned an incorrect request error response')
+            super(status_code, response_body, error_id, errors, message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/v1/webhooks/v1_webhooks_factory.rb

@@ -0,0 +1,27 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+require 'worldline/connect/sdk/json/default_marshaller'
+require 'worldline/connect/sdk/v1/webhooks/webhooks_helper'
+
+module Worldline
+  module Connect
+    module SDK
+      module V1
+        module Webhooks
+          # Worldline Global Collect platform factory for several v1 webhooks components
+          class V1WebhooksFactory
+
+            # Creates a WebhooksHelper that uses the given SecretKeyStore.
+            # @return [Worldline::Connect::SDK::V1::Webhooks::WebhooksHelper]
+            def create_helper(secret_key_store, marshaller: nil)
+              marshaller = DefaultMarshaller.instance unless marshaller
+              WebhooksHelper.new(marshaller, secret_key_store)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/v1/webhooks/webhooks_helper.rb

@@ -0,0 +1,45 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+require 'worldline/connect/sdk/v1/domain/webhooks_event'
+require 'worldline/connect/sdk/webhooks/api_version_mismatch_exception'
+require 'worldline/connect/sdk/webhooks/signature_validator'
+
+module Worldline
+  module Connect
+    module SDK
+      module V1
+        module Webhooks
+          # Worldline Global Collect platform v1 webhooks Helper, Thread-safe.
+          class WebhooksHelper
+            def initialize(marshaller, secret_key_store)
+              raise ArgumentError if marshaller.nil?
+              @marshaller = marshaller
+              @signature_validator = Worldline::Connect::SDK::Webhooks::SignatureValidator.new(secret_key_store)
+            end
+
+            # Unmarshals the given body, while also validating it using the given request headers.
+            #
+            # @param body            [String] body of the request
+            # @param request_headers [Array<Worldline::Connect::SDK::Communication::RequestHeader>] headers of the request
+            # @return [Worldline::Connect::SDK::V1::Domain::WebhooksEvent]
+            def unmarshal(body, request_headers)
+              @signature_validator.validate(body, request_headers)
+
+              event = @marshaller.unmarshal(body, Worldline::Connect::SDK::V1::Domain::WebhooksEvent)
+              validate_api_version(event)
+              event
+            end
+
+            private
+
+            def validate_api_version(event)
+              raise Worldline::Connect::SDK::Webhooks::ApiVersionMismatchException.new(event.api_version, 'v1') unless 'v1'.eql?(event.api_version)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/v1/webhooks.rb

@@ -0,0 +1,5 @@
+#
+# This file was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+Dir[File.join(__dir__, 'webhooks', '*.rb')].each { |f| require f }

data/lib/worldline/connect/sdk/v1.rb

@@ -0,0 +1,5 @@
+#
+# This file was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+Dir[File.join(__dir__, 'v1', '*.rb')].each { |f| require f }

data/lib/worldline/connect/sdk/webhooks/api_version_mismatch_exception.rb

@@ -0,0 +1,24 @@
+module Worldline
+  module Connect
+    module SDK
+      module Webhooks
+        # Raised when a webhooks event has an API version that is not supported by current version
+        # of SDK.
+        #
+        # @attr_reader [String] event_api_version The API version from the webhooks event.
+        # @attr_reader [String] sdk_api_version   The API version that this version of the SDK supports.
+        class ApiVersionMismatchException < RuntimeError
+
+          def initialize(event_api_version, sdk_api_version)
+            super("event API version #{event_api_version} is not compatible with SDK API version #{sdk_api_version}")
+            @event_api_version = event_api_version
+            @sdk_api_version = sdk_api_version
+          end
+
+          attr_reader :event_api_version
+          attr_reader :sdk_api_version
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/webhooks/in_memory_secret_key_store.rb

@@ -0,0 +1,61 @@
+require 'concurrent'
+require 'singleton'
+require 'worldline/connect/sdk/webhooks/secret_key_not_available_exception'
+require 'worldline/connect/sdk/webhooks/secret_key_store'
+
+module Worldline
+  module Connect
+    module SDK
+      module Webhooks
+        # An in-memory secret key store. This implementation can be used
+        # in applications where secret keys are specified at application
+        # startup. Thread-safe.
+        class InMemorySecretKeyStore
+          include Singleton
+          include SecretKeyStore
+
+          # Creates new InMemorySecretKeyStore
+          def initialize
+            # NOTE: use Map instead of Hash to provide better performance
+            # under high concurrency.
+            @store = Concurrent::Map.new
+          end
+
+          # Retrieves the secret key corresponding to the given key id
+          #
+          # @param key_id [String] key id of the secret key
+          # @raise [Worldline::Connect::SDK::Webhooks::SecretKeyNotAvailableException] if the secret key for the given key id is not available.
+          def get_secret_key(key_id)
+            if (secret_key = @store.get(key_id)).nil?
+              msg = "could not find secret key for key id " + key_id
+              raise SecretKeyNotAvailableException.new(message: msg, key_id: key_id)
+            end
+            secret_key
+          end
+
+          # Stores the given secret key for the given key id.
+          #
+          # @param key_id     [String] key id of the secret key
+          # @param secret_key [String] the secret key to be stored
+          def store_secret_key(key_id, secret_key)
+            raise ArgumentError if key_id.nil? or key_id.strip.empty?
+            raise ArgumentError if secret_key.nil? or secret_key.strip.empty?
+            @store.put(key_id, secret_key)
+          end
+
+          # Removes the secret key for the given key id.
+          #
+          # @param key_id [String] the key id whose corresponding secret should be removed from the store
+          def remove_secret_key(key_id)
+            @store.delete(key_id)
+          end
+
+          # Removes all stored secret keys from the store
+          def clear
+            @store.clear
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/webhooks/secret_key_not_available_exception.rb

@@ -0,0 +1,23 @@
+require 'worldline/connect/sdk/webhooks/signature_validation_exception'
+
+module Worldline
+  module Connect
+    module SDK
+      module Webhooks
+        # Raised when an error caused a secret to become not available.
+        #
+        # @attr_reader [String] key_id
+        class SecretKeyNotAvailableException < SignatureValidationException
+
+          def initialize(args)
+            raise ArgumentError if (key_id = args.delete(:key_id)).nil? # key_id is mandatory
+            super(args)
+            @key_id = key_id
+          end
+
+          attr_reader :key_id
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/webhooks/secret_key_store.rb

@@ -0,0 +1,20 @@
+module Worldline
+  module Connect
+    module SDK
+      module Webhooks
+        # An abstract store of secret keys. Implementation can store secret keys in a database,
+        # on disk, etc. Should be Thread-safe.
+        module SecretKeyStore
+
+          # Retrieve secret key for given key id
+          #
+          # @param key_id [String] key id of the secret key
+          # @raise [Worldline::Connect::SDK::Webhooks::SecretKeyNotAvailableException] if the secret key for the given key id is not available.
+          def get_secret_key(key_id)
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/webhooks/signature_validation_exception.rb

@@ -0,0 +1,22 @@
+module Worldline
+  module Connect
+    module SDK
+      module Webhooks
+        # Raised when an error occurred when validating Webhooks signatures
+        class SignatureValidationException < RuntimeError
+
+          # Creates a new SignatureValidationException
+          #
+          # @param [Hash] args the options to create the Exception with
+          # @option args [String] :message the error message
+          # @option args [RuntimeError] :cause an Error object that causes the Exception
+          def initialize(args)
+            super(args[:message]) # NOTE: can be nil
+            # store backtrace info if exception given
+            set_backtrace(args[:cause].backtrace) unless args[:cause].nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/webhooks/signature_validator.rb

@@ -0,0 +1,83 @@
+require 'base64'
+require 'openssl'
+require 'worldline/connect/sdk/webhooks/signature_validation_exception'
+
+module Worldline
+  module Connect
+    module SDK
+      module Webhooks
+
+        # Validator for webhooks signatures. Thread-safe.
+        class SignatureValidator
+          def initialize(secret_key_store)
+            raise ArgumentError if secret_key_store.nil?
+            @secret_key_store = secret_key_store
+          end
+
+          # Validates incoming request using request headers
+          #
+          # @param body            [String] body of the request
+          # @param request_headers [Array<Worldline::Connect::SDK::Communication::RequestHeader>] headers of the request
+          def validate(body, request_headers)
+            validate_body(body, request_headers)
+          end
+
+          private
+
+          HEADER_SIGNATURE = 'X-GCS-Signature'.freeze
+          HEADER_KEY_ID = 'X-GCS-KeyId'.freeze
+          HMAC_SCHEME = 'SHA256'.freeze
+
+          # Validates the body using given request headers
+          #
+          # @param body            [String] body of the request
+          # @param request_headers [Array<Worldline::Connect::SDK::Communication::RequestHeader>] headers of the request
+          def validate_body(body, request_headers)
+            signature = get_header_value(request_headers, HEADER_SIGNATURE)
+            key_id = get_header_value(request_headers, HEADER_KEY_ID)
+            secret_key = @secret_key_store.get_secret_key(key_id)
+            digest = OpenSSL::Digest.new(HMAC_SCHEME)
+            hmac = OpenSSL::HMAC.digest(digest, secret_key, body)
+            expected_signature = Base64.strict_encode64(hmac).strip
+
+            unless equal_signatures?(signature, expected_signature)
+              msg = "failed to validate signature '#{signature}'"
+              raise SignatureValidationException.new(message: msg)
+            end
+          end
+
+          # Checks two signatures
+          #
+          # @param signature          [String]
+          # @param expected_signature [String]
+          def equal_signatures?(signature, expected_signature)
+            # NOTE: copy the signatures to avoid runtime tampering via references
+            signature = signature.dup.freeze
+            expected_signature = expected_signature.dup.freeze
+            # NOTE: do not use simple equality comparision to avoid side channel attack
+            limit = [signature.length, expected_signature.length, 256].max
+            limit.times.inject(true) do |flag, idx|
+              # NOTE: this block is constructed to take constant time to run
+              flag &= signature[idx] == expected_signature[idx]
+              # [] returns nil if idx >= the length of the String
+            end
+          end
+
+          # Retrieves header value from the request headers whose header name matches the given parameter
+          def get_header_value(request_headers, header_name)
+            if (right_header = request_headers.select { |h| h.name.casecmp(header_name) == 0 }).size != 1
+              msg = if right_header.empty?
+                      "could not find header '#{header_name}'"
+                    else
+                      # more than 2 headers
+                      "encountered multiple occurrences of header '#{header_name}'"
+                    end
+              raise SignatureValidationException.new(message: msg)
+            end
+            right_header.first.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/connect/sdk/webhooks/webhooks.rb

@@ -0,0 +1,28 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+require 'worldline/connect/sdk/v1/webhooks/v1_webhooks_factory'
+
+module Worldline
+  module Connect
+    module SDK
+      module Webhooks
+        # Worldline Global Collect platform factory for several webhooks components
+        module Webhooks
+
+          private
+
+          V1 = Worldline::Connect::SDK::V1::Webhooks::V1WebhooksFactory.new
+
+          public
+
+          # @return [Worldline::Connect::SDK::V1::Webhooks::V1WebhooksFactory]
+          def self.v1
+            V1
+          end
+        end
+      end
+    end
+  end
+end

data/spec/comparable_extension.rb

@@ -1,6 +1,6 @@
-require 'ingenico/connect/sdk/request_param'
+require 'worldline/connect/sdk/communication/request_param'
 
-module Ingenico::Connect::SDK
+module Worldline::Connect::SDK::Communication
 
   # extension of the RequestParam object to support comparison
   class RequestParam

data/spec/fixtures/resources/properties.proxy.yml

@@ -1,10 +1,10 @@
 --- # YAML settings used in testing the SDK
-  connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+  connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
   connect.api.authorizationType: v1HMAC
   connect.api.connectTimeout: -1
   connect.api.socketTimeout: -1
   connect.api.maxConnections: 10
-  connect.api.integrator: Ingenico
+  connect.api.integrator: Worldline
   # change uri to preferred proxy
   connect.api.proxy.uri: http://localhost:9999
   # change username and password to authentication credentials for the proxy, omit the entries if no authentication is required

data/spec/fixtures/resources/properties.yml

@@ -1,7 +1,7 @@
 --- # YAML settings used in testing the SDK
-  connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+  connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
   connect.api.authorizationType: v1HMAC
   connect.api.connectTimeout: -1
   connect.api.socketTimeout: -1
   connect.api.maxConnections: 100
-  connect.api.integrator: Ingenico
+  connect.api.integrator: Worldline

data/spec/integration/connection_pooling_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'integration_setup'
-require 'ingenico/connect/sdk/merchant/services/convert_amount_params'
-require 'ingenico/connect/sdk/factory'
+require 'worldline/connect/sdk/factory'
+require 'worldline/connect/sdk/v1/merchant/services/convert_amount_params'
 require 'yaml'
 
 describe 'connection pooling with the server' do
@@ -49,7 +49,7 @@ end
 def run_connection_pooling_test(request_count, max_connections)
   configuration = Integration.init_communicator_configuration(max_connections: max_connections)
   begin
-    communicator = Ingenico::Connect::SDK::Factory.create_communicator_from_configuration(configuration)
+    communicator = Worldline::Connect::SDK::Factory.create_communicator_from_configuration(configuration)
     flag = Event.new
     runner_threads = Array.new(request_count){ |i| Thread.new{run_request(i, communicator, flag)} }
     flag.set
@@ -65,14 +65,14 @@ def run_connection_pooling_test(request_count, max_connections)
 end
 
 def run_request(i, communicator, flag)
-  request = Ingenico::Connect::SDK::Merchant::Services::ConvertAmountParams.new
+  request = Worldline::Connect::SDK::V1::Merchant::Services::ConvertAmountParams.new
   request.source = 'USD'
   request.target = 'EUR'
   request.amount = 100*(i+1)
 
-  client = Ingenico::Connect::SDK::Factory.create_client_from_communicator(communicator)
+  client = Worldline::Connect::SDK::Factory.create_client_from_communicator(communicator)
   flag.wait
   start_time = Time.now
-  client.merchant(Integration::MERCHANT_ID).services.convert_amount(request)
+  client.v1.merchant(Integration::MERCHANT_ID).services.convert_amount(request)
   [start_time.to_i*1000, Time.now.to_i*1000]
 end

data/spec/integration/convert_amount_spec.rb

@@ -2,22 +2,22 @@ require 'rspec'
 require 'spec_helper'
 require 'integration_setup'
 require 'webmock/rspec'
-require 'ingenico/connect/sdk/merchant/services/convert_amount_params'
+require 'worldline/connect/sdk/v1/merchant/services/convert_amount_params'
 
 describe 'convertAmount with the server' do
 
   before(:context){WebMock.allow_net_connect!}
   after(:context){WebMock.disable_net_connect!}
 
-  it 'communicates with the Ingenico ePayments platform' do
+  it 'communicates with the Worldline Global Collect platform' do
 
-    request = Ingenico::Connect::SDK::Merchant::Services::ConvertAmountParams.new
+    request = Worldline::Connect::SDK::V1::Merchant::Services::ConvertAmountParams.new
     request.amount = 123
     request.source = 'USD'
     request.target = 'EUR'
 
     Integration.init_client(false) do |client|
-      response = client.merchant(Integration::MERCHANT_ID).services.convert_amount(request)
+      response = client.v1.merchant(Integration::MERCHANT_ID).services.convert_amount(request)
       expect(response).to_not be_nil
       expect(response.converted_amount).to be > 0
     end

data/spec/integration/idempotence_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 require 'integration_setup'
 require 'securerandom'
 require 'webmock/rspec'
-require 'ingenico/connect/sdk/domain/definitions/amount_of_money'
-require 'ingenico/connect/sdk/domain/definitions/address'
-require 'ingenico/connect/sdk/domain/payment/create_payment_request'
-require 'ingenico/connect/sdk/domain/payment/customer'
-require 'ingenico/connect/sdk/domain/payment/order'
-require 'ingenico/connect/sdk/domain/payment/redirect_payment_product809_specific_input'
-require 'ingenico/connect/sdk/domain/payment/redirect_payment_method_specific_input'
-require 'ingenico/connect/sdk/call_context'
-require 'ingenico/connect/sdk/declined_payment_exception'
+require 'worldline/connect/sdk/call_context'
+require 'worldline/connect/sdk/v1/declined_payment_exception'
+require 'worldline/connect/sdk/v1/domain/amount_of_money'
+require 'worldline/connect/sdk/v1/domain/address'
+require 'worldline/connect/sdk/v1/domain/create_payment_request'
+require 'worldline/connect/sdk/v1/domain/customer'
+require 'worldline/connect/sdk/v1/domain/order'
+require 'worldline/connect/sdk/v1/domain/redirect_payment_product809_specific_input'
+require 'worldline/connect/sdk/v1/domain/redirect_payment_method_specific_input'
 
 describe 'Idempotence with the server' do
 
@@ -18,36 +18,36 @@ describe 'Idempotence with the server' do
   after(:context){WebMock.disable_net_connect!}
 
   it 'realises when an idempotent request is sent twice' do
-    amount_of_money = Ingenico::Connect::SDK::Domain::Definitions::AmountOfMoney.new
+    amount_of_money = Worldline::Connect::SDK::V1::Domain::AmountOfMoney.new
     amount_of_money.currency_code = 'EUR'
     amount_of_money.amount = 100
-    billing_address = Ingenico::Connect::SDK::Domain::Definitions::Address.new
+    billing_address = Worldline::Connect::SDK::V1::Domain::Address.new
     billing_address.country_code = 'NL'
-    customer = Ingenico::Connect::SDK::Domain::Payment::Customer.new
+    customer = Worldline::Connect::SDK::V1::Domain::Customer.new
     customer.locale = 'en'
     customer.billing_address = billing_address
-    order = Ingenico::Connect::SDK::Domain::Payment::Order.new
+    order = Worldline::Connect::SDK::V1::Domain::Order.new
     order.amount_of_money = amount_of_money
     order.customer = customer
-    payment_product_input = Ingenico::Connect::SDK::Domain::Payment::RedirectPaymentProduct809SpecificInput.new
+    payment_product_input = Worldline::Connect::SDK::V1::Domain::RedirectPaymentProduct809SpecificInput.new
     payment_product_input.issuer_id = 'INGBNL2A'
-    payment_method_input = Ingenico::Connect::SDK::Domain::Payment::RedirectPaymentMethodSpecificInput.new
+    payment_method_input = Worldline::Connect::SDK::V1::Domain::RedirectPaymentMethodSpecificInput.new
     payment_method_input.return_url = 'http://example.com'
     payment_method_input.payment_product_id = 809
     payment_method_input.payment_product809_specific_input = payment_product_input
-    body = Ingenico::Connect::SDK::Domain::Payment::CreatePaymentRequest.new
+    body = Worldline::Connect::SDK::V1::Domain::CreatePaymentRequest.new
     body.order = order
     body.redirect_payment_method_specific_input = payment_method_input
     idempotence_key = SecureRandom.uuid
-    context = Ingenico::Connect::SDK::CallContext.new(idempotence_key)
+    context = Worldline::Connect::SDK::CallContext.new(idempotence_key)
 
     Integration.init_client(false) do |client|
       def do_create_payment(client, body, context)
         # For this test it doesn't matter if the response is successful or declined,
         # as long as idempotence is handled correctly
         begin
-          client.merchant(Integration::MERCHANT_ID).payments.create(body, context)
-        rescue Ingenico::Connect::SDK::DeclinedPaymentException => ex
+          client.v1.merchant(Integration::MERCHANT_ID).payments.create(body, context)
+        rescue Worldline::Connect::SDK::V1::DeclinedPaymentException => ex
           ex.payment_result
         end
       end