apimatic-plaid-sdk 0.0.1

data/lib/plaid/apis/transactions_api.rb

@@ -0,0 +1,111 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # TransactionsApi
+  class TransactionsApi < BaseApi
+    # `/transactions/refresh` is an optional endpoint for users of the
+    # Transactions product. It initiates an on-demand extraction to fetch the
+    # newest transactions for an Item. This on-demand extraction takes place in
+    # addition to the periodic extractions that automatically occur multiple
+    # times a day for any Transactions-enabled Item. If changes to transactions
+    # are discovered after calling `/transactions/refresh`, Plaid will fire a
+    # webhook:
+    # [`TRANSACTIONS_REMOVED`](https://plaid.com/docs/api/webhooks#deleted-trans
+    # actions-detected) will be fired if any removed transactions are detected,
+    # and
+    # [`DEFAULT_UPDATE`](https://plaid.com/docs/api/webhooks#transactions-defaul
+    # t_update) will be fired if any new transactions are detected. New
+    # transactions can be fetched by calling `/transactions/get`.
+    # Access to `/transactions/refresh` in Production is specific to certain
+    # pricing plans. If you cannot access `/transactions/refresh` in Production,
+    # [contact Sales](https://www.plaid.com/contact) for assistance.
+    # @param [TransactionsRefreshRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transactions_refresh(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transactions/refresh',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransactionsRefreshResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # The `/transactions/get` endpoint allows developers to receive
+    # user-authorized transaction data for credit, depository, and some
+    # loan-type accounts (only those with account subtype `student`; coverage
+    # may be limited). For transaction history from investments accounts, use
+    # the [Investments
+    # endpoint](https://plaid.com/docs/api/products#investments) instead.
+    # Transaction data is standardized across financial institutions, and in
+    # many cases transactions are linked to a clean name, entity type, location,
+    # and category. Similarly, account data is standardized and returned with a
+    # clean name, number, balance, and other meta information where available.
+    # Transactions are returned in reverse-chronological order, and the sequence
+    # of transaction ordering is stable and will not shift.  Transactions are
+    # not immutable and can also be removed altogether by the institution; a
+    # removed transaction will no longer appear in `/transactions/get`.  For
+    # more details, see [Pending and posted
+    # transactions](https://plaid.com/docs/transactions/transactions-data/#pendi
+    # ng-and-posted-transactions).
+    # Due to the potentially large number of transactions associated with an
+    # Item, results are paginated. Manipulate the `count` and `offset`
+    # parameters in conjunction with the `total_transactions` response body
+    # field to fetch all available transactions.
+    # Data returned by `/transactions/get` will be the data available for the
+    # Item as of the most recent successful check for new transactions. Plaid
+    # typically checks for new data multiple times a day, but these checks may
+    # occur less frequently, such as once a day, depending on the institution.
+    # An Item's `status.transactions.last_successful_update` field will show the
+    # timestamp of the most recent successful update. To force Plaid to check
+    # for new transactions, you can use the `/transactions/refresh` endpoint.
+    # Note that data may not be immediately available to `/transactions/get`.
+    # Plaid will begin to prepare transactions data upon Item link, if Link was
+    # initialized with `transactions`, or upon the first call to
+    # `/transactions/get`, if it wasn't. To be alerted when transaction data is
+    # ready to be fetched, listen for the
+    # [`INITIAL_UPDATE`](https://plaid.com/docs/api/webhooks#transactions-initia
+    # l_update) and
+    # [`HISTORICAL_UPDATE`](https://plaid.com/docs/api/webhooks#transactions-his
+    # torical_update) webhooks. If no transaction history is ready when
+    # `/transactions/get` is called, it will return a `PRODUCT_NOT_READY` error.
+    # @param [TransactionsGetRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transactions_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transactions/get',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransactionsGetResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+  end
+end

data/lib/plaid/apis/transfer_api.rb

@@ -0,0 +1,214 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # TransferApi
+  class TransferApi < BaseApi
+    # `/transfer/event/sync` allows you to request up to the next 25 transfer
+    # events that happened after a specific `event_id`. Use the
+    # `/transfer/event/sync` endpoint to guarantee you have seen all transfer
+    # events.
+    # @param [TransferEventSyncRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transfer_event_sync(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfer/event/sync',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferEventSyncResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/transfer/list` endpoint to see a list of all your transfers and
+    # their statuses. Results are paginated; use the `count` and `offset` query
+    # parameters to retrieve the desired transfers.
+    # @param [TransferListRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transfer_list(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfer/list',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferListResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # The `/transfer/get` fetches information about the transfer corresponding
+    # to the given `transfer_id`.
+    # @param [TransferGetRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transfer_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfer/get',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferGetResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/transfer/cancel` endpoint to cancel a transfer.  A transfer is
+    # eligible for cancelation if the `cancellable` property returned by
+    # `/transfer/get` is `true`.
+    # @param [TransferCancelRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transfer_cancel(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfer/cancel',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferCancelResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/transfer/create` endpoint to initiate a new transfer.
+    # @param [TransferCreateRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transfer_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfer/create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferCreateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/transfer/authorization/create` endpoint to determine transfer
+    # failure risk.
+    # In Plaid's sandbox environment the decisions will be returned as follows:
+    #   - To approve a transfer, make an authorization request with an `amount`
+    # less than the available balance in the account.
+    #   - To decline a transfer with the rationale code `NSF`, the available
+    # balance on the account must be less than the authorization `amount`. See
+    # [Create Sandbox test data](https://plaid.com/docs/sandbox/user-custom/)
+    # for details on how to customize data in Sandbox.
+    #   - To decline a transfer with the rationale code `RISK`, the available
+    # balance on the account must be exactly $0. See [Create Sandbox test
+    # data](https://plaid.com/docs/sandbox/user-custom/) for details on how to
+    # customize data in Sandbox.
+    #   - To permit a transfer with the rationale code `MANUALLY_VERIFIED_ITEM`,
+    # create an Item in Link through the [Same Day Micro-deposits
+    # flow](https://plaid.com/docs/auth/coverage/testing/#testing-same-day-micro
+    # -deposits).
+    #   - To permit a transfer with the rationale code `LOGIN_REQUIRED`, [reset
+    # the login for an
+    # Item](https://plaid.com/docs/sandbox/#item_login_required).
+    # All username/password combinations other than the ones listed above will
+    # result in a decision of permitted and rationale code `ERROR`.
+    # @param [TransferAuthorizationCreateRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transfer_authorization_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfer/authorization/create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferAuthorizationCreateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/transfer/event/list` endpoint to get a list of transfer events
+    # based on specified filter criteria.
+    # @param [TransferEventListRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transfer_event_list(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfer/event/list',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferEventListResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+  end
+end

data/lib/plaid/apis/webhook_verification_key_api.rb

@@ -0,0 +1,36 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # WebhookVerificationKeyApi
+  class WebhookVerificationKeyApi < BaseApi
+    # Plaid signs all outgoing webhooks and provides JSON Web Tokens (JWTs) so
+    # that you can verify the authenticity of any incoming webhooks to your
+    # application. A message signature is included in the `Plaid-Verification`
+    # header.
+    # The `/webhook_verification_key/get` endpoint provides a JSON Web Key (JWK)
+    # that can be used to verify a JWT.
+    # @param [WebhookVerificationKeyGetRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def webhook_verification_key_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/webhook_verification_key/get',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WebhookVerificationKeyGetResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/plaid/client.rb

@@ -0,0 +1,208 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  #  plaid client class.
+  class Client
+    include CoreLibrary
+    attr_reader :config, :auth_managers
+
+    def user_agent_detail
+      config.user_agent_detail
+    end
+
+    # Access to item controller.
+    # @return [ItemApi] Returns the controller instance.
+    def item
+      @item ||= ItemApi.new @global_configuration
+    end
+
+    # Access to asset_report controller.
+    # @return [AssetReportApi] Returns the controller instance.
+    def asset_report
+      @asset_report ||= AssetReportApi.new @global_configuration
+    end
+
+    # Access to processor controller.
+    # @return [ProcessorApi] Returns the controller instance.
+    def processor
+      @processor ||= ProcessorApi.new @global_configuration
+    end
+
+    # Access to payment_initiation controller.
+    # @return [PaymentInitiationApi] Returns the controller instance.
+    def payment_initiation
+      @payment_initiation ||= PaymentInitiationApi.new @global_configuration
+    end
+
+    # Access to sandbox controller.
+    # @return [SandboxApi] Returns the controller instance.
+    def sandbox
+      @sandbox ||= SandboxApi.new @global_configuration
+    end
+
+    # Access to investments controller.
+    # @return [InvestmentsApi] Returns the controller instance.
+    def investments
+      @investments ||= InvestmentsApi.new @global_configuration
+    end
+
+    # Access to institutions controller.
+    # @return [InstitutionsApi] Returns the controller instance.
+    def institutions
+      @institutions ||= InstitutionsApi.new @global_configuration
+    end
+
+    # Access to application controller.
+    # @return [ApplicationApi] Returns the controller instance.
+    def application
+      @application ||= ApplicationApi.new @global_configuration
+    end
+
+    # Access to accounts controller.
+    # @return [AccountsApi] Returns the controller instance.
+    def accounts
+      @accounts ||= AccountsApi.new @global_configuration
+    end
+
+    # Access to identity controller.
+    # @return [IdentityApi] Returns the controller instance.
+    def identity
+      @identity ||= IdentityApi.new @global_configuration
+    end
+
+    # Access to liabilities controller.
+    # @return [LiabilitiesApi] Returns the controller instance.
+    def liabilities
+      @liabilities ||= LiabilitiesApi.new @global_configuration
+    end
+
+    # Access to auth controller.
+    # @return [AuthApi] Returns the controller instance.
+    def auth
+      @auth ||= AuthApi.new @global_configuration
+    end
+
+    # Access to transactions controller.
+    # @return [TransactionsApi] Returns the controller instance.
+    def transactions
+      @transactions ||= TransactionsApi.new @global_configuration
+    end
+
+    # Access to categories controller.
+    # @return [CategoriesApi] Returns the controller instance.
+    def categories
+      @categories ||= CategoriesApi.new @global_configuration
+    end
+
+    # Access to webhook_verification_key controller.
+    # @return [WebhookVerificationKeyApi] Returns the controller instance.
+    def webhook_verification_key
+      @webhook_verification_key ||= WebhookVerificationKeyApi.new @global_configuration
+    end
+
+    # Access to deposit_switch controller.
+    # @return [DepositSwitchApi] Returns the controller instance.
+    def deposit_switch
+      @deposit_switch ||= DepositSwitchApi.new @global_configuration
+    end
+
+    # Access to link controller.
+    # @return [LinkApi] Returns the controller instance.
+    def link
+      @link ||= LinkApi.new @global_configuration
+    end
+
+    # Access to transfer controller.
+    # @return [TransferApi] Returns the controller instance.
+    def transfer
+      @transfer ||= TransferApi.new @global_configuration
+    end
+
+    # Access to bank_transfer controller.
+    # @return [BankTransferApi] Returns the controller instance.
+    def bank_transfer
+      @bank_transfer ||= BankTransferApi.new @global_configuration
+    end
+
+    # Access to employers controller.
+    # @return [EmployersApi] Returns the controller instance.
+    def employers
+      @employers ||= EmployersApi.new @global_configuration
+    end
+
+    # Access to income controller.
+    # @return [IncomeApi] Returns the controller instance.
+    def income
+      @income ||= IncomeApi.new @global_configuration
+    end
+
+    # Access to signal controller.
+    # @return [SignalApi] Returns the controller instance.
+    def signal
+      @signal ||= SignalApi.new @global_configuration
+    end
+
+    def initialize(
+      connection: nil, adapter: :net_http_persistent, timeout: 60,
+      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,
+      plaid_client_id_credentials: nil, plaid_secret_credentials: nil,
+      plaid_version_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,
+                    plaid_client_id_credentials: plaid_client_id_credentials,
+                    plaid_secret_credentials: plaid_secret_credentials,
+                    plaid_version_credentials: plaid_version_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[PLAID-CLIENT-ID PLAID-SECRET Plaid-Version].each { |auth| @auth_managers[auth] = nil }
+      @auth_managers['PLAID-CLIENT-ID'] = PlaidClientId.new(
+        http_client_config.plaid_client_id_credentials
+      )
+      @auth_managers['PLAID-SECRET'] = PlaidSecret.new(http_client_config.plaid_secret_credentials)
+      @auth_managers['Plaid-Version'] = PlaidVersion.new(
+        http_client_config.plaid_version_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