univapay-apimatic-sdk 0.0.1

data/lib/univapay_client_sdk/apis/webhooks_api.rb

@@ -0,0 +1,463 @@
+# univapay_client_sdk
+#
+# This file was automatically generated for Univapay
+# by APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module UnivapayClientSdk
+  # WebhooksApi
+  class WebhooksApi < BaseApi
+    # Returns a paginated list of webhooks for the specified store. Requires a
+    # secret-bearing token.
+    # @param [UUID | String] store_id Required parameter: The unique identifier
+    # of the store.
+    # @param [Integer] limit Optional parameter: Maximum number of resources to
+    # return in one page.
+    # @param [UUID | String] cursor Optional parameter: Cursor pointing to the
+    # resource after which pagination should continue.
+    # @param [CursorDirectionQuery] cursor_direction Optional parameter:
+    # Pagination direction relative to the supplied cursor.
+    # @param [TrueClass | FalseClass] active Optional parameter: Filter by
+    # active status.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_webhooks(store_id,
+                      limit: 10,
+                      cursor: nil,
+                      cursor_direction: CursorDirectionQuery::DESC,
+                      active: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/stores/{storeId}/webhooks',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(store_id, key: 'storeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(cursor_direction, key: 'cursor_direction'))
+                   .query_param(new_parameter(active, key: 'active'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('JWT_TOKEN')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WebhookList.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error_template('401',
+                                          'HTTP 401 Unauthorized: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('404',
+                                          'HTTP 404 Not Found: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('400',
+                                          'HTTP 400 Bad Request: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('403',
+                                          'HTTP 403 Forbidden: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('409',
+                                          'HTTP 409 Conflict: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('429',
+                                          'HTTP 429 Rate Limited: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('500',
+                                          'HTTP 500 Server Error: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('503',
+                                          'HTTP 503 Unavailable: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('504',
+                                          'HTTP 504 Timeout: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('default',
+                                          'HTTP {$statusCode}: {$response.body#/code}',
+                                          APIException))
+        .execute
+    end
+
+    # Creates a new webhook subscription for the specified store. Requires a
+    # secret-bearing token. Duplicate URLs within the same scope are not
+    # allowed. There is a maximum limit on the number of webhooks per store.
+    # @param [UUID | String] store_id Required parameter: The unique identifier
+    # of the store.
+    # @param [WebhookCreateRequest] body Required parameter: Request payload for
+    # creating a store webhook subscription.
+    # @param [String] idempotency_key Optional parameter: An optional
+    # idempotency key to prevent double charges and duplicate operations. We
+    # recommend a randomly generated UUID (v4).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_webhook(store_id,
+                       body,
+                       idempotency_key: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/stores/{storeId}/webhooks',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(store_id, key: 'storeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('JWT_TOKEN')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Webhook.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error_template('400',
+                                          'HTTP 400 Bad Request: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('401',
+                                          'HTTP 401 Unauthorized: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('403',
+                                          'HTTP 403 Forbidden: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('404',
+                                          'HTTP 404 Not Found: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('409',
+                                          'HTTP 409 Conflict: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('429',
+                                          'HTTP 429 Rate Limited: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('500',
+                                          'HTTP 500 Server Error: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('503',
+                                          'HTTP 503 Unavailable: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('504',
+                                          'HTTP 504 Timeout: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('default',
+                                          'HTTP {$statusCode}: {$response.body#/code}',
+                                          APIException))
+        .execute
+    end
+
+    # Retrieves a specific webhook by ID.
+    # @param [UUID | String] store_id Required parameter: The unique identifier
+    # of the store.
+    # @param [UUID | String] id Required parameter: The unique identifier of the
+    # resource.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_webhook(store_id,
+                    id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/stores/{storeId}/webhooks/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(store_id, key: 'storeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('JWT_TOKEN')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Webhook.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error_template('401',
+                                          'HTTP 401 Unauthorized: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('404',
+                                          'HTTP 404 Not Found: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('400',
+                                          'HTTP 400 Bad Request: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('403',
+                                          'HTTP 403 Forbidden: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('409',
+                                          'HTTP 409 Conflict: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('429',
+                                          'HTTP 429 Rate Limited: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('500',
+                                          'HTTP 500 Server Error: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('503',
+                                          'HTTP 503 Unavailable: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('504',
+                                          'HTTP 504 Timeout: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('default',
+                                          'HTTP {$statusCode}: {$response.body#/code}',
+                                          APIException))
+        .execute
+    end
+
+    # Updates an existing webhook. All fields are optional; omitted fields are
+    # left unchanged. Duplicate URLs within the same scope are not allowed.
+    # @param [UUID | String] store_id Required parameter: The unique identifier
+    # of the store.
+    # @param [UUID | String] id Required parameter: The unique identifier of the
+    # resource.
+    # @param [WebhookUpdateRequest] body Required parameter: Request payload for
+    # updating a store webhook subscription.
+    # @param [String] idempotency_key Optional parameter: An optional
+    # idempotency key to prevent double charges and duplicate operations. We
+    # recommend a randomly generated UUID (v4).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_webhook(store_id,
+                       id,
+                       body,
+                       idempotency_key: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/stores/{storeId}/webhooks/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(store_id, key: 'storeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('JWT_TOKEN')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Webhook.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error_template('400',
+                                          'HTTP 400 Bad Request: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('401',
+                                          'HTTP 401 Unauthorized: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('403',
+                                          'HTTP 403 Forbidden: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('404',
+                                          'HTTP 404 Not Found: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('409',
+                                          'HTTP 409 Conflict: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('429',
+                                          'HTTP 429 Rate Limited: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('500',
+                                          'HTTP 500 Server Error: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('503',
+                                          'HTTP 503 Unavailable: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('504',
+                                          'HTTP 504 Timeout: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('default',
+                                          'HTTP {$statusCode}: {$response.body#/code}',
+                                          APIException))
+        .execute
+    end
+
+    # Deactivates and deletes a webhook subscription.
+    # @param [UUID | String] store_id Required parameter: The unique identifier
+    # of the store.
+    # @param [UUID | String] id Required parameter: The unique identifier of the
+    # resource.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def delete_webhook(store_id,
+                       id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/stores/{storeId}/webhooks/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(store_id, key: 'storeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .auth(Single.new('JWT_TOKEN')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error_template('401',
+                                          'HTTP 401 Unauthorized: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('403',
+                                          'HTTP 403 Forbidden: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('404',
+                                          'HTTP 404 Not Found: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('400',
+                                          'HTTP 400 Bad Request: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('409',
+                                          'HTTP 409 Conflict: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('429',
+                                          'HTTP 429 Rate Limited: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('500',
+                                          'HTTP 500 Server Error: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('503',
+                                          'HTTP 503 Unavailable: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('504',
+                                          'HTTP 504 Timeout: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('default',
+                                          'HTTP {$statusCode}: {$response.body#/code}',
+                                          APIException))
+        .execute
+    end
+
+    # Returns a paginated list of webhook delivery events for the specified
+    # webhook. Each event captures the result of a single webhook delivery
+    # attempt.
+    # @param [UUID | String] store_id Required parameter: The unique identifier
+    # of the store.
+    # @param [UUID | String] id Required parameter: The unique identifier of the
+    # resource.
+    # @param [Integer] limit Optional parameter: Maximum number of resources to
+    # return in one page.
+    # @param [UUID | String] cursor Optional parameter: Cursor pointing to the
+    # resource after which pagination should continue.
+    # @param [CursorDirectionQuery] cursor_direction Optional parameter:
+    # Pagination direction relative to the supplied cursor.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_webhook_events(store_id,
+                            id,
+                            limit: 10,
+                            cursor: nil,
+                            cursor_direction: CursorDirectionQuery::DESC)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/stores/{storeId}/webhooks/{id}/events',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(store_id, key: 'storeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(cursor_direction, key: 'cursor_direction'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('JWT_TOKEN')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WebhookEventList.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error_template('401',
+                                          'HTTP 401 Unauthorized: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('403',
+                                          'HTTP 403 Forbidden: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('404',
+                                          'HTTP 404 Not Found: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('400',
+                                          'HTTP 400 Bad Request: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('409',
+                                          'HTTP 409 Conflict: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('429',
+                                          'HTTP 429 Rate Limited: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('500',
+                                          'HTTP 500 Server Error: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('503',
+                                          'HTTP 503 Unavailable: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('504',
+                                          'HTTP 504 Timeout: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('default',
+                                          'HTTP {$statusCode}: {$response.body#/code}',
+                                          APIException))
+        .execute
+    end
+
+    # Re-sends the webhook payload for a previously delivered (or failed) event.
+    # Returns 202 Accepted immediately; delivery is asynchronous.
+    # @param [UUID | String] store_id Required parameter: The unique identifier
+    # of the store.
+    # @param [UUID | String] id Required parameter: The unique identifier of the
+    # resource.
+    # @param [UUID | String] event_id Required parameter: The unique identifier
+    # of the webhook event.
+    # @param [String] idempotency_key Optional parameter: An optional
+    # idempotency key to prevent double charges and duplicate operations. We
+    # recommend a randomly generated UUID (v4).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def redeliver_webhook_event(store_id,
+                                id,
+                                event_id,
+                                idempotency_key: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/stores/{storeId}/webhooks/{id}/events/{eventId}/redeliver',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(store_id, key: 'storeId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(event_id, key: 'eventId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('JWT_TOKEN')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:json_deserialize))
+                    .is_api_response(true)
+                    .local_error_template('401',
+                                          'HTTP 401 Unauthorized: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('403',
+                                          'HTTP 403 Forbidden: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('404',
+                                          'HTTP 404 Not Found: {$response.body#/code}',
+                                          ApiErrorException)
+                    .local_error_template('400',
+                                          'HTTP 400 Bad Request: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('409',
+                                          'HTTP 409 Conflict: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('429',
+                                          'HTTP 429 Rate Limited: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('500',
+                                          'HTTP 500 Server Error: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('503',
+                                          'HTTP 503 Unavailable: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('504',
+                                          'HTTP 504 Timeout: {$response.body#/code}',
+                                          APIException)
+                    .local_error_template('default',
+                                          'HTTP {$statusCode}: {$response.body#/code}',
+                                          APIException))
+        .execute
+    end
+  end
+end

data/lib/univapay_client_sdk/client.rb

@@ -0,0 +1,116 @@
+# univapay_client_sdk
+#
+# This file was automatically generated for Univapay
+# by APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module UnivapayClientSdk
+  #  univapay_client_sdk client class.
+  class Client
+    include CoreLibrary
+    attr_reader :config, :auth_managers
+
+    def user_agent_detail
+      config.user_agent_detail
+    end
+
+    # Access to charges controller.
+    # @return [ChargesApi] Returns the controller instance.
+    def charges
+      @charges ||= ChargesApi.new @global_configuration
+    end
+
+    # Access to transaction_tokens controller.
+    # @return [TransactionTokensApi] Returns the controller instance.
+    def transaction_tokens
+      @transaction_tokens ||= TransactionTokensApi.new @global_configuration
+    end
+
+    # Access to refunds controller.
+    # @return [RefundsApi] Returns the controller instance.
+    def refunds
+      @refunds ||= RefundsApi.new @global_configuration
+    end
+
+    # Access to subscriptions controller.
+    # @return [SubscriptionsApi] Returns the controller instance.
+    def subscriptions
+      @subscriptions ||= SubscriptionsApi.new @global_configuration
+    end
+
+    # Access to cancels controller.
+    # @return [CancelsApi] Returns the controller instance.
+    def cancels
+      @cancels ||= CancelsApi.new @global_configuration
+    end
+
+    # Access to merchants controller.
+    # @return [MerchantsApi] Returns the controller instance.
+    def merchants
+      @merchants ||= MerchantsApi.new @global_configuration
+    end
+
+    # Access to stores controller.
+    # @return [StoresApi] Returns the controller instance.
+    def stores
+      @stores ||= StoresApi.new @global_configuration
+    end
+
+    # Access to webhooks controller.
+    # @return [WebhooksApi] Returns the controller instance.
+    def webhooks
+      @webhooks ||= WebhooksApi.new @global_configuration
+    end
+
+    def initialize(
+      connection: nil, adapter: :net_http_persistent, timeout: 30,
+      max_retries: 0, retry_interval: 1, backoff_factor: 2,
+      retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+      retry_methods: %i[get put], http_callback: nil, proxy_settings: nil,
+      logging_configuration: nil, environment: Environment::PRODUCTION,
+      base_url: 'https://api.univapay.com', bearer_auth_credentials: nil,
+      config: nil
+    )
+      @config = if config.nil?
+                  Configuration.new(
+                    connection: connection, adapter: adapter, timeout: timeout,
+                    max_retries: max_retries, retry_interval: retry_interval,
+                    backoff_factor: backoff_factor,
+                    retry_statuses: retry_statuses,
+                    retry_methods: retry_methods, http_callback: http_callback,
+                    proxy_settings: proxy_settings,
+                    logging_configuration: logging_configuration,
+                    environment: environment, base_url: base_url,
+                    bearer_auth_credentials: bearer_auth_credentials
+                  )
+                else
+                  config
+                end
+      user_agent_params = BaseApi.user_agent_parameters
+
+      @global_configuration = GlobalConfiguration.new(client_configuration: @config)
+                                                 .base_uri_executor(@config.method(:get_base_uri))
+                                                 .global_errors(BaseApi::GLOBAL_ERRORS)
+                                                 .user_agent(BaseApi.user_agent,
+                                                             agent_parameters: user_agent_params)
+
+      initialize_auth_managers(@global_configuration)
+      @global_configuration = @global_configuration.auth_managers(@auth_managers)
+    end
+
+    # Initializes the auth managers hash used for authenticating API calls.
+    # @param [GlobalConfiguration] global_config The global configuration of the SDK)
+    def initialize_auth_managers(global_config)
+      @auth_managers = {}
+      http_client_config = global_config.client_configuration
+      %w[JWT_TOKEN].each { |auth| @auth_managers[auth] = nil }
+      @auth_managers['JWT_TOKEN'] = Oauth2.new(http_client_config.bearer_auth_credentials)
+    end
+
+    # Creates a client directly from environment variables.
+    def self.from_env(**overrides)
+      default_config = Configuration.build_default_config_from_env
+      new_config = default_config.clone_with(**overrides)
+      new(config: new_config)
+    end
+  end
+end