pq-api-matic-sdk 1.0.0

data/lib/pay_quicker_sdk/controllers/electronic_wallets_controller.rb

@@ -0,0 +1,280 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # ElectronicWalletsController
+  class ElectronicWalletsController < BaseController
+    # Retrieve a list of [electronic wallets](page:resources/electronic-wallets)
+    # that supports filtering, sorting, and pagination through existing
+    # mechanisms.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [ElectronicWalletListResult] Response from the API call.
+    def list_electronic_wallets(user_token,
+                                page,
+                                page_size,
+                                filter: nil,
+                                sort: nil,
+                                language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/electronic-wallets',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ElectronicWalletListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a new [electronic wallet](page:resources/electronic-wallets) using
+    # a user token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [CreateOrUpdateElectronicWallet] body Optional parameter: TODO:
+    # type description here
+    # @return [ElectronicWalletResult] Response from the API call.
+    def create_electronic_wallet(user_token,
+                                 body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users/{user-token}/electronic-wallets',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ElectronicWalletResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve requirements for adding a [electronic
+    # wallet](page:resources/electronic-wallets) using the parameters provided.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [ElectronicWalletTypes] electronic_wallet_type Optional parameter:
+    # Filter results by electronic wallet type.
+    # @param [Countries] country Optional parameter: Filter results by
+    # country.
+    # @param [Currencies] currency Optional parameter: Filter results by
+    # currency.
+    # @return [ElectronicWalletRequirementListResult] Response from the API call.
+    def retrieve_creation_requirements(user_token,
+                                       electronic_wallet_type: nil,
+                                       country: nil,
+                                       currency: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/electronic-wallets/requirements',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(electronic_wallet_type, key: 'electronicWalletType'))
+                   .query_param(new_parameter(country, key: 'country'))
+                   .query_param(new_parameter(currency, key: 'currency'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ElectronicWalletRequirementListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single [electronic wallet](page:resources/electronic-wallets)
+    # using a destination token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [ElectronicWalletResult] Response from the API call.
+    def retrieve_electronic_wallet(user_token,
+                                   destination_token,
+                                   page,
+                                   page_size,
+                                   filter: nil,
+                                   sort: nil,
+                                   language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/electronic-wallets/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ElectronicWalletResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Update a [electronic wallet](page:resources/electronic-wallets).
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [CreateOrUpdateElectronicWallet] body Optional parameter: TODO:
+    # type description here
+    # @return [ElectronicWalletResult] Response from the API call.
+    def update_electronic_wallet(user_token,
+                                 destination_token,
+                                 body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/users/{user-token}/electronic-wallets/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ElectronicWalletResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Delete a user [electronic wallet](page:resources/electronic-wallets).
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @return [OperationResult] Response from the API call.
+    def delete_electronic_wallet(user_token,
+                                 destination_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/users/{user-token}/electronic-wallets/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OperationResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/events_controller.rb

@@ -0,0 +1,75 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # EventsController
+  class EventsController < BaseController
+    # Retrieve a list of [user events](page:resources/user#list-user-events)
+    # that supports filtering, sorting, and pagination through existing
+    # mechanisms.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @return [EventListResult] Response from the API call.
+    def list_events(user_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/events',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(EventListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single [user event](page:resources/user#get-user-event).
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] event_token Required parameter: Auto-generated unique
+    # identifier representing an event, prefixed with `evnt-`.
+    # @return [UserEventResult] Response from the API call.
+    def retrieve_event(user_token,
+                       event_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/events/{event-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(event_token, key: 'event-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UserEventResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/invitations_controller.rb

@@ -0,0 +1,179 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # InvitationsController
+  class InvitationsController < BaseController
+    # Retrieve a list of [invitations](page:resources/invitations) that supports
+    # filtering, sorting, and pagination through existing mechanisms.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [InvitationListResult] Response from the API call.
+    def list_invitations(page,
+                         page_size,
+                         filter: nil,
+                         sort: nil,
+                         language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/invitations',
+                                     Server::API)
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(InvitationListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a [invitation](page:resources/invitations) quote.
+    # @param [CreateInvitation] body Optional parameter: TODO: type description
+    # here
+    # @return [InvitationResult] Response from the API call.
+    def create_invitation(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/invitations',
+                                     Server::API)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(InvitationResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single [invitation](page:resources/invitations).
+    # @param [String] invitation_token Required parameter: Auto-generated unique
+    # identifier representing an invite, prefixed with `invt-`.
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [InvitationResult] Response from the API call.
+    def retrieve_invitation(invitation_token,
+                            filter: nil,
+                            language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/invitations/{invitation-token}',
+                                     Server::API)
+                   .template_param(new_parameter(invitation_token, key: 'invitation-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(InvitationResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Accept an open [invitation](page:resources/invitations) quote.
+    # @param [String] invitation_token Required parameter: Auto-generated unique
+    # identifier representing an invite, prefixed with `invt-`.
+    # @return [InvitationResult] Response from the API call.
+    def update_invitation(invitation_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/invitations/{invitation-token}',
+                                     Server::API)
+                   .template_param(new_parameter(invitation_token, key: 'invitation-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(InvitationResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Cancel an open [invitation](page:resources/invitations) quote.
+    # @param [String] invitation_token Required parameter: Auto-generated unique
+    # identifier representing an invite, prefixed with `invt-`.
+    # @return [InvitationResult] Response from the API call.
+    def cancel_invitation(invitation_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/invitations/{invitation-token}',
+                                     Server::API)
+                   .template_param(new_parameter(invitation_token, key: 'invitation-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(InvitationResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end