old_plaid 1.7.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e23d2716fc03c0effd63bce96fc15cbb22e8eae1
+  data.tar.gz: 6151243d04e3526aede1dc2230ac7dbfd7a5c0f8
+SHA512:
+  metadata.gz: 5f3756351df4b41b7f3618a88b6a6d7bd06eac8145f2e8451c9f6722f4eba3f44eeb8438b85d9528d1c70fc29e244e859c8fd3cea35bec0e3a3378fddd87f2d2
+  data.tar.gz: f5c5ea2875da40efbee3755d9dd909ea7284f8c0e44e9fca9672d15143c874051c8e6bd7a092fa959d90a4ed7fa5ac12f5b3eac8b2e8d937b94fde9016dc7bb2

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.3
+sudo: false
+

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Justin Crites
+
+MIT License
+
+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/PUBLISHING.md

@@ -0,0 +1,21 @@
+# Publishing
+
+The module is published to the [rubygems.org][1] under the gem name [old_plaid][2].
+
+The publishing process is handled by [rake][3].
+
+After updating the package version, run:
+
+```console
+$ rake spec
+$ rake build
+$ rake release
+```
+
+See the [semantic versioning][4] guidelines to determine what level of release to publish.
+
+[1]: https://rubygems.org
+[2]: https://rubygems.org/gems/old_plaid
+[3]: https://github.com/ruby/rake
+[4]: http://semver.org
+

data/README.md

@@ -0,0 +1,125 @@
+# OldPlaid [![Build Status](https://travis-ci.org/plaid/plaid-ruby.svg?branch=release_v_1.0.0)](https://travis-ci.org/plaid/plaid-ruby) [![Gem Version](https://badge.fury.io/rb/plaid.svg)](http://badge.fury.io/rb/plaid)
+
+Ruby bindings for the OldPlaid API
+
+## Notes
+
+This version is a beta version that contains failing tests for the new 'info' endpoint. While these have been tested individually on real accounts the tests here will fail with the test accounts supplied. These will be updated soon with test credentials.
+
+Latest stable version: **1.7.1**
+
+This version removes the need to use 'type' in each additional call.
+
+**Warning: If you have been using any version < 1 please switch to the correct branch (V0.1.6). Installing without specifying a version from RubyGems results in V1.1 build. **
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'old_plaid'
+```
+
+And install
+
+    $ bundle
+
+Or install it system wide as:
+
+    $ gem install old_plaid
+
+## Usage
+
+Please read the great documentation at http://plaid.com/docs/ for more information.
+
+### Configuring OldPlaid
+Configure the gem with your customer id, secret key, and the environment path you would like to use.
+
+```ruby
+OldPlaid.config do |p|
+  p.customer_id = 'OldPlaid provided customer ID here'
+  p.secret = 'OldPlaid provided secret key here'
+  p.environment_location = 'URL for the development or production environment'
+  # i.e. 'https://tartan.plaid.com/' for development, or
+  # 'https://api.plaid.com/' for production
+end
+```
+
+### Creating a new OldPlaid User
+Authenticate a user to your desired level of api access (auth / connect).
+
+```ruby
+user = OldPlaid.add_user('auth', 'plaid_test', 'plaid_good', 'wells')
+```
+
+If the authentication requires a pin, you can pass it in as the fifth argument:
+
+```ruby
+user = OldPlaid.add_user('auth', 'plaid_test', 'plaid_good', 'usaa', '1234')
+```
+
+To add options such as `login_only` or `webhooks`, use the sixth argument:
+
+```ruby
+user = OldPlaid.add_user('auth', 'plaid_test', 'plaid_good', 'wells', nil, { login_only: true, webhooks: 'https://example.org/callbacks/plaid')
+```
+
+### Restoring a OldPlaid User using an access token
+
+```ruby
+user = OldPlaid.set_user('access_token')
+```
+
+```ruby
+user = OldPlaid.set_user('access_token', ['connect'])
+```
+
+### Exchanging a Link public_token for a OldPlaid access_token
+
+```ruby
+OldPlaid.config do |p|
+  p.customer_id = 'test_id'
+  p.secret = 'test_secret'
+  p.environment_location = 'https://tartan.plaid.com'
+end
+
+# Exchange a Link public_token for a OldPlaid access_token
+exchangeTokenResponse = OldPlaid.exchange_token('test,chase,connected')
+# Optionally include an account_id
+exchangeTokenResponse = OldPlaid.exchange_token('test,chase,connected', 'account_id')
+
+# Use the API access_token to initialize a user
+# Note: This example assumes you are using Link with the "auth" product
+user = OldPlaid.set_user(exchangeTokenResponse.access_token, ['auth'])
+
+# Retrieve the user's accounts
+user.get('auth')
+
+# Print the name of each account
+user.accounts.each { |account| print account.meta['name'] + "\n"}
+```
+
+## Semantic Versioning
+
+Methods marked with `API: public` are officially supported by the gem maintainers. Since
+we are using semantic versioning (http://semver.org/spec/v2.0.0.html), the maintainers are
+committed to backwards-compatibility support for these API calls when we update the Minor
+version. So for example, going from version 1.4.x to 1.5.x will not change these public
+API calls.
+
+However, we may change these method signatures or even the gem architecture when updating
+the Major number. For example, we have some breaking changes in mind with version 2.0
+
+Methods marked with `API: semi-private` are used internally for consistency. While it is
+possible to monkey-patch against them for your own use, the maintainers make no guarantees
+on backwards compatibility.
+
+## Learn More
+
+Learn about the full functionality of the library on our [Wiki](https://github.com/plaid/plaid-ruby/wiki)
+
+## Contribute
+
+We highly encourage helping out with the gem. Either adding more tests, building new helper classes, fixing bugs, or anything to increase overall quality.
+
+Learn more about best practices, submitting a pull request, and rules for the build on our [Wiki](https://github.com/plaid/plaid-ruby/wiki/Contribute!)

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default  => :spec
+

data/lib/old_plaid.rb

@@ -0,0 +1,100 @@
+require 'old_plaid/version'
+require 'old_plaid/config'
+require 'old_plaid/errors'
+
+require 'old_plaid/models/user'
+require 'old_plaid/models/institution'
+require 'old_plaid/models/category'
+require 'old_plaid/models/exchange_token_response'
+
+require 'json'
+
+module OldPlaid
+  autoload :Connection, 'old_plaid/connection'
+
+  class << self
+    # Configures the gem with the public, private, and environment vars
+    include Configure
+
+    # API: public
+    # Use this to create a new OldPlaid user
+    # Required parameters:
+    #   api_level, username, password, type
+    # TODO: Rename this to something more descriptive for 2.0, such as 'create_user`
+    def add_user(api_level, username, password, type, pin = nil, options = nil)
+      payload = { username: username, password: password, type: type }
+
+      payload[:pin]     = pin if pin
+      payload[:options] = options.is_a?(Hash) ? JSON.generate(options) : options if options
+
+      res = Connection.post(api_level, payload)
+      User.build(res, api_level)
+    end
+
+    # API: public
+    # Exchange a OldPlaid Link public_token for a OldPlaid access_token
+    # Required parameters:
+    #   public_token
+    #   account_id (optional)
+    def exchange_token(public_token, account_id = nil)
+      payload = { public_token: public_token }
+      # include the account id, if set
+      payload[:account_id] = account_id if account_id
+
+      res = Connection.post('exchange_token', payload)
+      ExchangeTokenResponse.new(res)
+    end
+
+    # API: public
+    # Use this to restore a user from OldPlaid based upon the access token
+    # TODO: Rename this to something more descriptive for 2.0, such as 'get_user'
+    def set_user(token, api_levels=[], institution_type=nil)
+      _user = User.new
+      _user.access_token = fully_qualified_token(token, institution_type)
+      _user.permissions = api_levels
+      api_levels.each { |l| _user.get(l) }
+      _user
+    end
+
+    # API: public
+    # Given an access code and query options, use this to get a dataset of
+    # transactions and accounts for # a given user. See /connect/get endpoint
+    #
+    # Returns a User object with accounts and transactions within
+    # the date range given
+    # Examples:
+    #   OldPlaid.transactions 'test_wells', account: 'QPO8Jo8vdDHMepg41PBwckXm4KdK1yUdmXOwK'
+    def transactions(token, options = {})
+      _user = User.new
+      _user.access_token = token
+      _user.permit! 'connect'
+
+      # TODO: For 2.0, submit all data as JSON
+      options = JSON.generate(options) if options.kind_of?(Hash)
+
+      _user.get_connect(options: options)
+      _user
+    end
+
+    # API: public
+    # Returns the fully-qualified token based upon type
+    # Note: Don't see this documented in the OldPlaid API docs, need to investigate this
+    def fully_qualified_token(token, institution_type)
+      institution_type.nil? ? token : token + '_' + institution_type
+    end
+
+    # API: public
+    # Builds an institution object and returns when the institution details exist
+    def institution(id = nil)
+      res = Connection.get('institutions', id)
+      id.nil? ? Institution.all(res) : Institution.new(res)
+    end
+
+    # API: public
+    # Builds an category object and returns when the category details exist
+    def category(id = nil)
+      res = Connection.get('categories', id)
+      id.nil? ? Category.all(res) : Category.new(res)
+    end
+  end
+end

data/lib/old_plaid/config.rb

@@ -0,0 +1,19 @@
+module OldPlaid
+  module Configure
+    attr_accessor :customer_id, :secret, :environment_location
+
+    KEYS = [:customer_id, :secret, :environment_location]
+
+    def config
+      yield self
+
+      # Add trailing slash to api url if it is not present
+      if self.environment_location[-1] != '/'
+        self.environment_location += '/'
+      end
+
+      self
+    end
+
+  end
+end

data/lib/old_plaid/connection.rb

@@ -0,0 +1,109 @@
+require 'net/http'
+require 'json'
+require 'uri'
+
+module OldPlaid
+  class Connection
+    class << self
+      # API: semi-private
+      def post(path, options = {})
+        uri = build_uri(path)
+        options.merge!(client_id: OldPlaid.customer_id, secret: OldPlaid.secret)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        request = Net::HTTP::Post.new(uri.path)
+        request.set_form_data(options)
+        res = http.request(request)
+        parse_response(res)
+      end
+
+      # API: semi-private
+      def get(path, id = nil)
+        uri = build_uri(path,id)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        request = Net::HTTP::Get.new(uri.path)
+        res = http.request(request)
+        parse_get_response(res.body)
+      end
+
+      # API: semi-private
+      def secure_get(path, access_token, options = {})
+        uri = build_uri(path)
+        options.merge!({access_token:access_token})
+        req = Net::HTTP::Get.new(uri.path)
+        req.body = URI.encode_www_form(options) if options
+        req.content_type = 'application/x-www-form-urlencoded'
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+        parse_response(res)
+      end
+
+      # API: semi-private
+      def patch(path, options = {})
+        uri = build_uri(path)
+        options.merge!(client_id: OldPlaid.customer_id, secret: OldPlaid.secret)
+        req = Net::HTTP::Patch.new(uri.path)
+        req.body = URI.encode_www_form(options) if options
+        req.content_type = 'application/x-www-form-urlencoded'
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+        parse_response(res)
+      end
+
+      # API: semi-private
+      def delete(path, options = {})
+        uri = build_uri(path)
+        options.merge!(client_id: OldPlaid.customer_id, secret: OldPlaid.secret)
+        req = Net::HTTP::Delete.new(uri.path)
+        req.body = URI.encode_www_form(options) if options
+        req.content_type = 'application/x-www-form-urlencoded'
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+      end
+
+      protected
+
+      # API: semi-private
+      def build_uri(path, option = nil)
+        path = path + '/' + option unless option.nil?
+        URI.parse(OldPlaid.environment_location + path)
+      end
+
+      private
+
+      def parse_response(res)
+        # unfortunately, the JSON gem will raise an exception if the response is empty
+        raise OldPlaid::ServerError.new(res.code, res.msg, '') if res.body.to_s.length < 2
+        # we got a response from the server, so parse it
+        body = JSON.parse(res.body)
+        case res.code.delete('.').to_i
+        when 200 then body
+        when 201 then { msg: 'Requires further authentication', body: body}
+        when 400
+          raise OldPlaid::BadRequest.new(body['code'], body['message'], body['resolve'])
+        when 401
+          raise OldPlaid::Unauthorized.new(body['code'], body['message'], body['resolve'])
+        when 402
+          raise OldPlaid::RequestFailed.new(body['code'], body['message'], body['resolve'])
+        when 404
+          raise OldPlaid::NotFound.new(body['code'], body['message'], body['resolve'])
+        else
+          raise OldPlaid::ServerError.new(body['code'], body['message'], body['resolve'])
+        end
+      end
+
+      def parse_get_response(res)
+        body = JSON.parse(res)
+        return body if body.kind_of?(Array)
+
+        case body['code']
+        when nil
+          body
+        when 1301, 1401, 1501, 1601
+          raise OldPlaid::NotFound.new(body['code'], body['message'], body['resolve'])
+        else
+          body
+        end
+      end
+
+    end
+  end
+end