plaid-legacy 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 033f6f757e2de0376d156aec59eb4d95ea01529e
+  data.tar.gz: 47bbaf501af5899ac400372b58179e4ba43ce1ee
+SHA512:
+  metadata.gz: 10c2984cecf8ca20d7794ea3abee7ddb9ec7eb974198ba81e01b4d11df61eb8111720b65c79a99b891db9715bb9ff2db553a15f18b0ccba388b92955d541af5e
+  data.tar.gz: 3a6199ba74f95ad1dc384893548382320d2d2eaf5cbc1c726e5ea24abee2e35b0b0f65907aa607194eed266ca1fb046a550c980c4e26d362b896bf9cf474fded

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+# 3.0.0. 17-Jan-2017
+
+* Add `/institutions/all` and `/institutions/all/search` endpoints, see [UPGRADING.md](UPGRADING.md#upgrading-from-2xx-to-300)
+
+# 2.2.0. 03-Nov-2016
+
+* Add `Transaction#reference_number` (@ericbirdsall).
+* Fix webhook codes and add risk and income webhooks.
+
+# 2.1.0. 19-Oct-2016
+
+* Documentation fixes (@ishmael).
+* Fix `Transaction#to_s` behavior (@michel-tricot).
+* PATCH `/:product/step` flow.
+* Use the same client in `User#upgrade` (@betesh).
+* Webhook object (@zshannon).
+* `processor_token` access in `User.exchange_token` (@gylaz).
+* Raise `ServerError` in case server returned an empty response body.
+
+# 2.0.0. 24-May-2016
+
+* Use `~> 1.0` spec for multi_json dependency.
+* Support `stripe_bank_account_token` in `User.exchange_token`.
+
+# 2.0.0.alpha.2. 14-May-2016
+
+* Use `:production` instead of `:api` to signify production environment
+  in `Plaid::Client#env=`.
+* `User#mfa_step` allows to specify options now (thanks @gcweeks).
+* Implemented `User#update_webhook`.
+
+# 2.0.0.alpha. 06-May-2016
+
+* Rewrite everything.

data/CONTRIBUTING.md

@@ -0,0 +1,15 @@
+# Contributing
+
+1.  Make one or more atomic commits, and ensure that each commit has a
+    descriptive commit message. Commit messages should be line wrapped
+    at 72 characters.
+
+2.  Make sure that there are tests for the code you wrote.
+
+3.  Make sure that you've documented all public methods using [TomDoc](http://tomdoc.org/).
+
+4.  Run `rake test`, and address any errors. Preferably, fix commits
+    in place using `git rebase` or `git commit --amend` to make the
+    changes easier to review.
+
+5.  Open a pull request.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in plaid.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Plaid Technologies, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,328 @@
+# plaid-ruby-legacy [![Build Status](https://travis-ci.org/plaid/plaid-ruby-legacy-legacy.svg)](https://travis-ci.org/plaid/plaid-ruby-legacy) [![Gem Version](https://badge.fury.io/rb/plaid-legacy.svg)](http://badge.fury.io/rb/plaid-legacy)
+
+Ruby bindings for the Plaid's legacy API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'plaid-legacy'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install plaid-legacy
+
+The gem supports Ruby 2.x only.
+
+## Usage
+
+This gem wraps the Plaid API, which is fully described in the [documentation](http://plaid.com/docs).
+
+The RubyDoc for the gem is available [here](http://plaid.github.io/plaid-ruby-legacy).
+
+### Configuring access to Plaid
+
+Configure the gem with your client id, secret, and the environment you would like to use.
+
+```ruby
+Plaid.config do |p|
+  p.client_id = '<<< Plaid provided client ID >>>'
+  p.secret = '<<< Plaid provided secret key >>>'
+  p.env = :tartan  # or :production
+end
+```
+
+### Creating a new User
+
+```ruby
+user = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good')
+```
+
+This call will do a `POST /connect`. The response will contain account information and transactions
+for last 30 days, which you can find in `user.accounts` and `user.initial_transactions`, accordingly.
+
+If the authentication requires a pin, you can pass it as a named parameter:
+
+```ruby
+user = Plaid::User.create(:income, 'usaa', 'plaid_test', 'plaid_good', pin: '1234')
+```
+
+To add options such as `login_only` or `webhook`, use `options` argument:
+
+```ruby
+user = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good',
+                          options: { login_only: true, webhook: 'https://example.org/callbacks/plaid')
+```
+
+The first argument for `Plaid::User.create` is always a product you want to add the user to (like,
+`:connect`, `:auth`, `:info`, `:income`, or `:risk`). The user object is bound to the product, and subsequent
+calls like `user.update` or `user.delete` are done for this product (i.e., `PATCH /info` and `DELETE /info`
+for `:info`).
+
+### Instantiating a User with an existing access token
+
+If you've already added the user and saved the access token, you should use `User.load`:
+
+```ruby
+user = Plaid::User.load(:risk, 'access_token')
+```
+
+This won't make any API requests by itself, just set the product and the token in the `User` instance.
+
+### Exchanging a Link public token for a Plaid access token
+
+If you have a Link public token, use `User.exchange_token`:
+
+```ruby
+user = Plaid::User.exchange_token('public_token')   # bound to :connect product
+```
+
+With more options:
+
+```ruby
+user2 = Plaid::User.exchange_token('public_token', 'account_id', product: :auth)
+```
+
+If you want to [move money via Stripe's ACH
+API](https://plaid.com/docs/link/stripe/#step-4-write-server-side-handler), you
+ought to specify the `account_id` param. In this case the returned user
+instance will have the `stripe_bank_account_token` attribute set.
+
+### Upgrading and changing the current product
+
+Plaid supports upgrading a user, i.e. adding it to another product:
+
+```ruby
+# Create a user in Connect
+user = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good')
+
+# Upgrade this user, attaching it to Auth as well (makes a request to /upgrade).
+auth_user = user.upgrade(:auth)
+```
+
+The `auth_user` will be a different instance of `User`, attached to Auth, but the access token will be the same.
+
+Sometimes you know that the user has already been added to another product. To get a `User` instance with
+same access token, but different current product, use `User.for_product`:
+
+```ruby
+# Get a user attached to Connect
+user = Plaid::User.load(:connect, 'access_token')
+
+# Makes no requests
+info_user = user.for_product(:info)
+```
+
+Basically it's the same as:
+
+```ruby
+info_user = Plaid::User.load(:info, 'access_token')
+```
+
+### MFA (Multi-Factor Authorization)
+
+If MFA is requested by the financial institution, the `User.create` call would behave
+a bit differently:
+
+```ruby
+user = Plaid::User.create(:auth, 'wells', 'plaid_test', 'plaid_good')
+
+user.accounts   #=> nil
+user.mfa?       #=> true
+user.mfa_type   #=> :questions
+user.mfa        #=> [{question: "What's the nickname of the person who created Ruby?"}]
+```
+
+In this case you'll have to submit the answer to the question:
+
+```ruby
+user.mfa_step('matz')        # This is the correct answer!
+
+user.mfa?       #=> false
+user.mfa_type   #=> nil
+user.mfa        #=> nil
+user.accounts   #=> [<Plaid::Account ...>, ...]
+```
+
+The code-based MFA workflow is similar. Basically you need to call `user.mfa_step(...)`
+until `user.mfa?` becomes false.
+
+### Obtaining user-related data
+
+If you have a live `User` instance, you can use following methods
+(independent of instance's current product):
+
+* `user.transactions(...)`. Makes a `/connect/get` request.
+* `user.auth(sync: false)`. Makes an `/auth/get` request.
+* `user.info(sync: false)`. Makes an `/info/get` request.
+* `user.income(sync: false)`. Makes an `/income/get` request.
+* `user.risk(sync: false)`. Makes an `/risk/get` request.
+* `user.balance`. Makes an `/balance` request.
+
+All of these methods return appropriate data, but they also update the cached `user.accounts`. That is,
+if you user has access to Auth and Risk  products, the following code:
+
+```ruby
+user = User.load(:auth, 'access_token')
+user.auth
+user.risk
+```
+will result in `user.accounts` having both routing number and risk information for all the accounts. The
+subsequent `user.balance` call will just update the current balance, not touching the routing and risk information.
+
+The `sync` flag, if set to true, will result in updating the information from the server even if it has already been
+loaded. Otherwise cached information will be returned:
+
+```ruby
+user = User.load(:auth, 'access_token')   # Just set the token
+user.auth                                 # POST /auth/get
+user.auth                                 # No POST, return cached info
+user.auth(sync: true)                     # POST /auth/get again
+```
+
+Same goes for other methods, except `User#transactions` and `User#balance` which always make requests to the API.
+
+### Categories
+
+You can request category information:
+
+```ruby
+cats = Plaid::Category.all             # Array of all known categories
+cat  = Plaid::Category.get('17001013') # A single category by its ID
+```
+
+### Institutions
+
+Financial institution information is available via `Plaid::Institution`.
+
+```ruby
+insts = Plaid::Institution.all(count: 20, offset: 20)        # A page
+inst  = Plaid::Institution.get('5301a93ac140de84910000e0')   # A single institution by its ID
+
+res  = Plaid::Institution.search(query: 'c')         # Lookup by name
+```
+
+### Webhooks
+
+You can register to receive [Webhooks](https://plaid.com/docs/legacy/api/#webhook) from Plaid when your users have new events. If you do, you'll receive `POST` requests with JSON.
+
+E.g. Initial Transaction Webhook:
+```json
+{
+ "message": "Initial transaction pull finished",
+ "access_token": "xxxxx",
+ "total_transactions": 123,
+ "code": 0
+}
+```
+
+You should parse that JSON into a Ruby Hash with String keys (eg. `webhook_hash = JSON.parse(json_string)`). Then, you can convert that Hash into a Ruby object using `Plaid::Webhook`:
+
+```ruby
+webhook = Plaid::Webhook.new(webhook_hash)
+
+# Was that the Initial Transaction Webhook?
+webhook.initial_transaction?
+access_token = webhook.access_token
+total_transactions = webhook.total_transactions
+
+# Or did Historical Transactions become available?
+webhook.historical_transaction?
+access_token = webhook.access_token
+total_transactions = webhook.total_transactions
+
+# Or did Normal Transactions become available?
+webhook.normal_transaction?
+access_token = webhook.access_token
+total_transactions = webhook.total_transactions
+
+# Or maybe a transaction was removed?
+webhook.removed_transaction?
+access_token = webhook.access_token
+removed_transactions_ids = webhook.removed_transactions_ids
+
+# Or was the User's Webhook Updated?
+webhook.user_webhook_updated?
+access_token = webhook.access_token
+
+# Otherwise, was it an error?
+webhook.error_response?
+# Which error?
+error = webhook.error
+```
+
+### Custom clients
+
+It's possible to use several Plaid environments and/or credentials in one app by
+explicit instantiation of `Plaid::Client`:
+
+```ruby
+# Configuring the global client (Plaid.client) which is used by default
+Plaid.config do |p|
+  p.client_id = 'client_id_1'
+  p.secret = 'secret_1'
+  p.env = :tartan
+end
+
+# Creating a custom client
+api = Plaid::Client.new(client_id: 'client_id_2', secret: 'secret_2', env: :production)
+
+# Tartan user (using default client)
+user1 = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good')
+
+# Api user (using api client)
+user2 = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good', client: api)
+
+# Lookup an institution in production
+res = Plaid::Institution.search(query: 'c', client: api)
+```
+
+The `client` option can be passed to the following methods:
+
+* `User.create`
+* `User.load`
+* `User.exchange_token`
+* `Category.all`
+* `Category.get`
+* `Institution.all`
+* `Institution.get`
+* `Institution.search`
+* `Institution.search_by_id`
+
+### Errors
+
+Any methods making API calls will result in an exception raised unless the response code is "200: Success" or
+"201: MFA Required".
+
+`Plaid::BadRequestError` is raised when status code is "400: Bad Request".
+
+`Plaid::UnauthorizedError` is raised when status code is "401: Unauthorized".
+
+`Plaid::RequestFailedError` is raised when status code is "402: Request Failed".
+
+`Plaid::NotFoundError` is raised when status code is "404: Cannot be Found".
+
+`Plaid::ServerError` is raised when status code is "50X: Server Error".
+
+Read more about response codes and their meaning in the
+[Plaid documentation](https://plaid.com/docs/legacy/api/#response-codes).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/plaid/plaid-ruby-legacy. See also [contributing guidelines](CONTRIBUTING.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,54 @@
+require 'bundler/gem_tasks'
+require 'sdoc'
+require 'rdoc/task'
+require 'rake/testtask'
+require 'fileutils'
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.generator = 'sdoc'
+  rdoc.main = 'README.md'
+
+  rdoc.rdoc_files.include('README.md', 'LICENSE', 'UPGRADING.md',
+                          'CONTRIBUTING.md', 'CHANGELOG.md', 'lib/**/*.rb')
+  rdoc.markup = 'tomdoc'
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+  t.ruby_opts << '-rminitest/pride'
+end
+
+desc 'Update the gh-pages branch with doc/rdoc contents'
+task :update_gh_pages do
+  tmpdir = Dir::Tmpname.create('plaid_docs') {}
+
+  desc = `git describe`.chomp
+
+  sh "git clone --shared . #{tmpdir}"
+
+  Dir.chdir(tmpdir) do
+    sh 'git checkout gh-pages'
+    FileUtils.rm_rf Dir.glob("#{tmpdir}/*")
+  end
+
+  FileUtils.cp_r Dir.glob('doc/rdoc/*'), tmpdir
+
+  Dir.chdir(tmpdir) do
+    sh 'git add .'
+    sh 'git add --update .'
+    sh "git commit --allow-empty -m 'Regenerate docs for #{desc}'"
+    sh 'git push'
+  end
+
+  FileUtils.rm_rf tmpdir
+end
+
+desc 'Generate rdoc and update gh-pages on GitHub'
+task update_github_docs: %i(rdoc update_gh_pages) do
+  sh 'git push origin gh-pages'
+end
+
+task default: :test