plaid 3.0.0 → 4.0.0

data/lib/plaid/products/accounts.rb

@@ -0,0 +1,60 @@
+module Plaid
+  # Public: Class used to call the Balance product.
+  class Balance
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Get information about all available balances.
+    #
+    # Does a POST /accounts/balance/get call to get real-time balance information for all
+    # accounts associated with the access_token's item
+    #
+    # access_token - access_token who's item to fetch balances for
+    # account_ids  - Specific account ids to fetch balances for (optional)
+    # options      - Additional options to be merged into API request
+    #
+    # Returns a parsed JSON of balance response
+    def get(access_token, account_ids: nil, options: nil)
+      options_payload = {}
+      options_payload[:account_ids] = account_ids unless account_ids.nil?
+      options_payload = options_payload.merge(options) unless options.nil?
+
+      payload = { access_token: access_token,
+                  options: options_payload }
+      @client.post_with_auth('accounts/balance/get', payload)
+    end
+  end
+
+  # Public: Class used to call the Accounts product.
+  class Accounts
+    # Public: Memoized class instance to make requests from Plaid::Balance
+    def balance
+      @balance ||= Plaid::Balance.new(@client)
+    end
+
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Get information about all available accounts.
+    #
+    # Does a POST /accounts/get call to retrieve high level account information
+    # associated with an access_token's item
+    #
+    # access_token - access_token who's item to fetch accounts for
+    # account_ids  - Specific account ids to fetch accounts for (optional)
+    # options      - Additional options to be merged into API request
+    #
+    # Returns a parsed JSON of account information
+    def get(access_token, account_ids: nil, options: nil)
+      options_payload = {}
+      options_payload[:account_ids] = account_ids unless account_ids.nil?
+      options_payload = options_payload.merge(options) unless options.nil?
+
+      payload = { access_token: access_token,
+                  options: options_payload }
+      @client.post_with_auth('accounts/get', payload)
+    end
+  end
+end

data/lib/plaid/products/auth.rb

@@ -0,0 +1,29 @@
+module Plaid
+  # Public: Class used to call the Auth product.
+  class Auth
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Get information about account and routing numbers for checking
+    # and savings accounts
+    #
+    # Does a POST /auth/get call which returns high level account information along with
+    # account and routing numbers for checking and savings accounts
+    #
+    # access_token - access_token who's item to fetch Auth for
+    # account_ids  - Specific account ids to fetch numbers for (optional)
+    # options      - Additional options to merge into API request
+    #
+    # Returns a parsed JSON of Auth information
+    def get(access_token, account_ids: nil, options: nil)
+      options_payload = {}
+      options_payload[:account_ids] = account_ids unless account_ids.nil?
+      options_payload = options_payload.merge(options) unless options.nil?
+
+      payload = { access_token: access_token,
+                  options: options_payload }
+      @client.post_with_auth('auth/get', payload)
+    end
+  end
+end

data/lib/plaid/products/categories.rb

@@ -0,0 +1,18 @@
+module Plaid
+  # Public: Class used to call the Categories product.
+  class Categories
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Get information about all Plaid categories
+    #
+    # Does a POST /categories/get call to retrieve a list of all categories.
+    #
+    # Returns a parsed JSON of a list of categories
+    def get
+      payload = {}
+      @client.post('categories/get', payload)
+    end
+  end
+end

data/lib/plaid/products/credit_details.rb

@@ -0,0 +1,21 @@
+module Plaid
+  # Public: Class used to call the CreditDetails product.
+  class CreditDetails
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Get information about all available credit_details
+    #
+    # Does a POST /credit_details/get call which fetches credit details associated with
+    # and access_token's item
+    #
+    # access_token - access_token who's item to fetch credit_details for
+    #
+    # Returns a parsed JSON of credit_details information
+    def get(access_token)
+      payload = { access_token: access_token }
+      @client.post_with_auth('credit_details/get', payload)
+    end
+  end
+end

data/lib/plaid/products/identity.rb

@@ -0,0 +1,20 @@
+module Plaid
+  # Public: Class used to call the Identity product.
+  class Identity
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Get Identity information
+    #
+    # Does a POST /identity/get call to retrieve all info for a given access_token's item
+    #
+    # access_token - access_token who's item to fetch Identity data for
+    #
+    # Returns a parsed JSON of Identity information
+    def get(access_token)
+      payload = { access_token: access_token }
+      @client.post_with_auth('identity/get', payload)
+    end
+  end
+end

data/lib/plaid/products/income.rb

@@ -0,0 +1,20 @@
+module Plaid
+  # Public: Class used to call the Income product.
+  class Income
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Get information about user incomes
+    #
+    # Does a POST /income/get call which returns income info for an access_tokeni's item
+    #
+    # access_token - access_token who's item to fetch income for
+    #
+    # Returns a parsed JSON of income information
+    def get(access_token)
+      payload = { access_token: access_token }
+      @client.post_with_auth('income/get', payload)
+    end
+  end
+end

data/lib/plaid/products/institutions.rb

@@ -0,0 +1,51 @@
+module Plaid
+  # Public: Class used to call the Institutions product.
+  class Institutions
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Get information about Plaid institutions
+    #
+    # Does a POST /institutions/get call pulls a list of supported Plaid institutions
+    # with the information for each institution
+    #
+    # count  - Amount of institutions to pull
+    # offset - Offset to start pulling institutions
+    #
+    # Returns a parsed JSON of listed institution information
+    def get(count:, offset:)
+      payload = { count: count,
+                  offset: offset }
+      @client.post_with_auth('institutions/get', payload)
+    end
+
+    # Public: Get information about a Plaid institution by ID
+    #
+    # Does a POST /institutions/get_by_id call which allows you to pull
+    # information for an institution by ID
+    #
+    # institution_id - Specific institution id to fetch information for
+    #
+    # Returns a parsed JSON of institution info for your institution id
+    def get_by_id(institution_id)
+      payload = { institution_id: institution_id }
+      @client.post_with_public_key('institutions/get_by_id', payload)
+    end
+
+    # Public: Get information about all available institutions matching your query
+    #
+    # Does a POST /institutions/search call which allows you to pull a list of institutions
+    # using a query parameter
+    #
+    # query   - Search query to attempt to match institutions to
+    # producs - Product supported filter (optional)
+    #
+    # Returns a parsed JSON listing institution information
+    def search(query, products = nil)
+      payload = { query: query,
+                  products: products }
+      @client.post_with_public_key('institutions/search', payload)
+    end
+  end
+end

data/lib/plaid/products/item.rb

@@ -0,0 +1,230 @@
+module Plaid
+  # Public: Class used to call the AccessToken sub-product.
+  class AccessToken
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Rotate your access_token, keeping it attached to the item
+    #
+    # Does a POST /item/access_token/invalidate call which will give you a new access_token
+    # allowing you to rotate access_tokens
+    #
+    # access_token - access_token to invalidate and rotate
+    #
+    # Returns a parsed JSON with the new access_token and request id
+    def invalidate(access_token)
+      payload = { access_token: access_token }
+      @client.post_with_auth('item/access_token/invalidate', payload)
+    end
+
+    # Public: Generate a new API access_token for a legacy access_token
+    #
+    # Does a POST /item/access_token/update_version call which will give you
+    # an access_token for the new API.
+    #
+    # access_token_v1 - legacy access_token
+    #
+    # Returns a parsed JSON with the new access_token and request id
+    def update_version(access_token_v1)
+      payload = { access_token_v1: access_token_v1 }
+      @client.post_with_auth('item/access_token/update_version', payload)
+    end
+  end
+
+  # Public: Class used to call the Credentials sub-product.
+  class Credentials
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Update credentials for an access_token.
+    #
+    # Does a POST /item/credentials/update call which is used to update credentials
+    # if the credentials become no longer valid
+    #
+    # access_token - access_token who's item to update credentials for
+    # credentials  - New credentials
+    #
+    # Returns a parsed JSON of either an ItemStatus or MFA response
+    def update(access_token, credentials)
+      payload = { access_token: access_token,
+                  credentials: credentials }
+      @client.post_with_auth('item/credentials/update', payload)
+    end
+  end
+
+  # Public: Class used to call the PublicToken sub-product
+  class PublicToken
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Creates a public token from an access_token.
+    #
+    # Does a POST /item/public_token/create call which can be used to initialize Link
+    # in update mode
+    #
+    # access_token - access_token to create a public token for
+    #
+    # Returns a parsed JSON containing a public token and token info
+    def create(access_token)
+      payload = { access_token: access_token }
+      @client.post_with_auth('item/public_token/create', payload)
+    end
+
+    # Public: Exchange a public token for an access_token
+    #
+    # Does a POST /item/public_token/exchange call helps you exchange a public token
+    # (possibly from Plaid Link) for an access_token you can use in the rest of your app
+    #
+    # public_token - Public token to get an access_token from
+    #
+    # Returns a parsed JSON with an access_token and request id
+    def exchange(public_token)
+      payload = { public_token: public_token }
+      @client.post_with_auth('item/public_token/exchange', payload)
+    end
+  end
+
+  # Public: Class used to call the Webhook sub-product
+  class Webhook
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Update webhook for an access_token
+    #
+    # Does a POST /item/webhook/update call which is used to update webhook
+    # for a particular access_token, webhooks are used to be notified when
+    # transactions for an item are updated and ready
+    #
+    # access_token - access_token who's item to update webhood for
+    # webhook      - a new webhook link
+    #
+    # Returns a parsed JSON of either an ItemStatus or MFA response
+    def update(access_token, webhook)
+      payload = { access_token: access_token,
+                  webhook: webhook }
+      @client.post_with_auth('item/webhook/update', payload)
+    end
+  end
+
+  # Public: Class used to call the Item product.
+  class Item
+    # Public: Memoized class instance to make requests from Plaid::AccessToken
+    def access_token
+      @access_token ||= Plaid::AccessToken.new(@client)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Credentials
+    def credentials
+      @credentials ||= Plaid::Credentials.new(@client)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::PublicToken
+    def public_token
+      @public_token ||= Plaid::PublicToken.new(@client)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Webhook
+    def webhook
+      @webhook ||= Plaid::Webhook.new(@client)
+    end
+
+    def initialize(client)
+      @client = client
+    end
+
+    # Public: Creates an item.
+    #
+    # Does a POST /item/create call which attemps to create a new item for you
+    # possibly returning a success, error, or multi-factor authentication response
+    #
+    # credentials                 - Institution credentials to create item with
+    # institution_id              - Institution ID to create item with
+    # initial_products            - Initial products to create the item with i.e. ['transactions']
+    # transactions_start_date     - date at which to begin the item's initial transaction pull
+    #                              (optional)
+    # transactions_end_date       - date at which to end the item's initial transaction pull
+    #                              (optional)
+    # transactions_await_results  - if true, the initial transaction pull will be performed
+    #                              synchronously (optional)
+    # webhook                     - webhook to associate with the item (optional)
+    # options                     - Additional options to merge into API request
+    #
+    # Returns a parsed JSON of item info including access_token and ItemStatus or
+    # MFA response or error
+    def create(credentials:,
+               institution_id:,
+               initial_products:,
+               transactions_start_date: nil,
+               transactions_end_date: nil,
+               transactions_await_results: nil,
+               webhook: nil,
+               options: nil)
+
+      transactions_options = {}
+      unless transactions_start_date.nil?
+        transactions_options[:start_date] = Plaid.convert_to_date_string(transactions_start_date)
+      end
+      unless transactions_end_date.nil?
+        transactions_options[:end_date] = Plaid.convert_to_date_string(transactions_end_date)
+      end
+      unless transactions_await_results.nil?
+        transactions_options[:await_results] = transactions_await_results
+      end
+
+      options_payload = {}
+      options_payload[:transactions] = transactions_options if transactions_options != {}
+      options_payload[:webhook] = webhook unless webhook.nil?
+      options_payload = options_payload.merge(options) unless options.nil?
+
+      payload = { credentials: credentials,
+                  institution_id: institution_id,
+                  initial_products: initial_products,
+                  options: options_payload }
+      @client.post_with_auth('item/create', payload)
+    end
+
+    # Public: Submit an MFA step.
+    #
+    # Does a POST /item/mfa call which gives you the ability to response to an MFA
+    #
+    # access_token - To submit MFA step for
+    # mfa_type     - The MFA type indicated in the MFA response
+    # responses    - List of answers/responses to MFA
+    #
+    # Returns a parsed JSON of ItemStatus or another MFA step
+    def mfa(access_token, mfa_type, responses)
+      payload = { access_token: access_token,
+                  mfa_type: mfa_type,
+                  responses: responses }
+      @client.post_with_auth('item/mfa', payload)
+    end
+
+    # Public: Get information about an item
+    #
+    # Does a POST /item/get call which returns information about an item or ItemStatus
+    #
+    # access_token - access_token who's item to fetch status for
+    #
+    # Returns a parsed JSON of item information
+    def get(access_token)
+      payload = { access_token: access_token }
+      @client.post_with_auth('item/get', payload)
+    end
+
+    # Public: Deletes an item
+    #
+    # Does a POST /item/delete call which is used to delete an item
+    #
+    # access_token - access_token who's item to delete
+    #
+    # Returns a parsed JSON of delete result
+    def delete(access_token)
+      payload = { access_token: access_token }
+      @client.post_with_auth('item/delete', payload)
+    end
+  end
+end