old_plaid 1.7.1

data/lib/old_plaid/errors.rb

@@ -0,0 +1,27 @@
+module OldPlaid
+  class OldPlaidError < StandardError
+    attr_reader :code
+    attr_reader :resolve
+
+    def initialize(code, message, resolve)
+      super(message)
+      @code = code
+      @resolve = resolve
+    end
+  end
+
+  class BadRequest < OldPlaidError
+  end
+
+  class Unauthorized < OldPlaidError
+  end
+
+  class RequestFailed < OldPlaidError
+  end
+
+  class NotFound < OldPlaidError
+  end
+
+  class ServerError < OldPlaidError
+  end
+end

data/lib/old_plaid/models/account.rb

@@ -0,0 +1,24 @@
+module OldPlaid
+  class Account
+    attr_accessor :available_balance, :current_balance, :institution_type, :meta, :transactions, :numbers, :name, :id, :type, :subtype
+
+    def initialize(hash)
+      @id   = hash['_id']
+      @name = hash['meta']['name'] if hash['meta']
+      @type = hash['type']
+      @meta = hash['meta']
+      @institution_type  = hash['institution_type']
+
+      if hash['balance']
+        @available_balance = hash['balance']['available']
+        @current_balance   = hash['balance']['current']
+      end
+
+      # Depository account only, "checkings" or "savings"
+      # Available on live data, but not on the test data
+      @subtype = hash['subtype']
+
+      @numbers = hash['numbers'] ? hash['numbers'] : 'Upgrade user to access routing information for this account'
+    end
+  end
+end

data/lib/old_plaid/models/category.rb

@@ -0,0 +1,17 @@
+module OldPlaid
+  class Category
+    attr_accessor :type, :hierarchy, :id
+
+    def initialize(fields = {})
+      @type = fields['type']
+      @hierarchy = fields['hierarchy']
+      @id = fields['id']
+    end
+
+    # API: semi-private
+    # This method takes an array returned from the API and instantiates all of the categories
+    def self.all(res)
+      res.map { |cat| new(cat) }
+    end
+  end
+end

data/lib/old_plaid/models/exchange_token_response.rb

@@ -0,0 +1,11 @@
+module OldPlaid
+  class ExchangeTokenResponse
+    attr_accessor :access_token
+    attr_accessor :stripe_bank_account_token
+
+    def initialize(fields = {})
+      @access_token = fields['access_token']
+      @stripe_bank_account_token = fields['stripe_bank_account_token']
+    end
+  end
+end

data/lib/old_plaid/models/info.rb

@@ -0,0 +1,12 @@
+module OldPlaid
+  class Information
+    attr_accessor :names, :emails, :phone_numbers, :addresses
+
+    def initialize(hash)
+      @names = hash['names']
+      @emails = hash['emails']
+      @phone_numbers = hash['phone_numbers']
+      @addresses = hash['addresses']
+    end
+  end
+end

data/lib/old_plaid/models/institution.rb

@@ -0,0 +1,22 @@
+module OldPlaid
+  class Institution
+    attr_accessor :id, :name, :type, :has_mfa, :mfa, :credentials, :products
+
+    def initialize(fields = {})
+      @id = fields['id']
+      @name = fields['name']
+      @type = fields['type']
+      @has_mfa = fields['has_mfa']
+      @mfa = fields['mfa']
+      @credentials = fields['credentials']
+      @products = fields['products']
+    end
+
+    # API: semi-private
+    # This method takes an array returned from the API and instantiates all of the institutions
+    def self.all(res)
+      res.map { |inst| new(inst) }
+    end
+  end
+end
+

data/lib/old_plaid/models/transaction.rb

@@ -0,0 +1,24 @@
+module OldPlaid
+  class Transaction
+    attr_accessor :id, :account, :date, :amount, :name, :meta, :location, :pending, :score, :cat, :type, :category, :category_id, :pending_transaction
+
+    def initialize(fields = {})
+      @id = fields['_id']
+      @account = fields['_account']
+      @date = fields['date']
+      @amount = fields['amount']
+      @name = fields['name']
+      @location = fields['meta'].nil? ? {} : fields['meta']['location']
+      @pending = fields['pending']
+      @pending_transaction = fields['_pendingTransaction']
+      @score = fields['score']
+      @cat = Category.new({ 'id' => fields['category_id'], 'hierarchy' => fields['category'], 'type' => fields['type'] })
+
+      # Here for backwards compatibility only.
+      @type = fields['type']
+      @category = fields['category']
+      @category_id = fields['category_id']
+      @meta = fields['meta']
+    end
+  end
+end

data/lib/old_plaid/models/user.rb

@@ -0,0 +1,189 @@
+require_relative 'account'
+require_relative 'transaction'
+require_relative 'info'
+require 'json'
+
+module OldPlaid
+  class User
+    attr_accessor :accounts, :transactions, :access_token, :type, :permissions, :api_res, :pending_mfa_questions, :info, :information
+
+    # API: public
+    # Use this method to select the MFA method
+    def select_mfa_method(selection, type=nil)
+      type = self.type if type.nil?
+      auth_path = self.permissions.last + '/step'
+      res = Connection.post(auth_path, { options: { send_method: selection }.to_json, access_token: self.access_token, type: type })
+      update(res, self.permissions.last)
+    end
+
+    # API: public
+    # Use this method to send back the MFA code or answer
+    def mfa_authentication(auth, type = nil)
+      type = self.type if type.nil?
+      auth_path = self.permissions.last + '/step'
+      res = Connection.post(auth_path, { mfa: auth, access_token: self.access_token, type: type })
+      self.accounts = []
+      self.transactions = []
+      update(res)
+    end
+
+    # API: public
+    # Use this method to find out API levels available for this user
+    def permit?(auth_level)
+      self.permissions.include? auth_level
+    end
+
+    # API: public
+    # Use this method to upgrade a user to another api level
+    def upgrade(api_level=nil)
+      if api_level.nil?
+        api_level = 'auth' unless self.permit? 'auth'
+        api_level = 'connect' unless self.permit? 'connect'
+      end
+      res = Connection.post('upgrade', { access_token: self.access_token, upgrade_to: api_level })
+
+      # Reset accounts and transaction
+      self.accounts = []
+      self.transactions = []
+      update(res)
+    end
+
+    # API: public
+    # Use this method to delete a user from the OldPlaid API
+    def delete_user
+      Connection.delete('info', { access_token: self.access_token })
+    end
+
+    ### Internal build methods
+    def initialize
+      self.accounts = []
+      self.transactions = []
+      self.permissions = []
+      self.access_token = ''
+      self.api_res = ''
+      self.info = {}
+    end
+
+    # API: semi-private
+    # This class method instantiates a new Account object and updates it with the results
+    # from the API
+    def self.build(res, api_level = nil)
+      self.new.update(res, api_level)
+    end
+
+    # API: semi-private
+    # This method updates Account with the results returned from the API
+    def update(res, api_level = nil)
+      self.permit! api_level
+
+      if res[:msg].nil?
+        populate_user!(res)
+        clean_up_user!
+      else
+        set_mfa_request!(res)
+      end
+
+      self
+    end
+
+    # Internal helper methods
+
+    # API: semi-private
+    # Internal helper method to set the available API levels
+    def permit!(api_level)
+      return if api_level.nil? || self.permit?(api_level)
+      self.permissions << api_level
+    end
+
+    # API: semi-private
+    # Gets auth, connect, or info of the user
+    # TODO: (2.0) auth_level should be symbols instead of string
+    def get(auth_level, options = {})
+      return false unless self.permit? auth_level
+      case auth_level
+      when 'auth'
+        update(Connection.post('auth/get', access_token: self.access_token))
+      when 'connect'
+        payload = { access_token: self.access_token }.merge(options)
+        update(Connection.post('connect/get', payload))
+      when 'info'
+        update(Connection.secure_get('info', self.access_token))
+      else
+        raise "Invalid auth level: #{auth_level}"
+      end
+    end
+
+    # API: semi-private
+    def get_auth
+      get('auth')
+    end
+
+    # API: semi-private
+    def get_connect(options={})
+      get('connect', options)
+    end
+
+    # API: semi-private
+    def get_info
+      get('info')
+    end
+
+    # API: semi-private
+    # Helper method to update user information
+    # Requires 'info' api level
+    def update_info(username,pass,pin=nil)
+      return false unless self.permit? 'info'
+
+      payload = { username: username, password: pass, access_token: self.access_token }
+      payload.merge!(pin: pin) if pin
+      update(OldPlaid.patch('info', payload))
+    end
+
+    # API: semi-private
+    # Helper method to update user balance
+    def update_balance
+      update(Connection.post('balance', { access_token: self.access_token }))
+    end
+
+    private
+
+    def clean_up_user!
+      self.accounts.select! { |c| c.instance_of? Account }
+    end
+
+    def set_mfa_request!(res)
+      self.access_token = res[:body]['access_token']
+      self.pending_mfa_questions = res[:body]
+      self.api_res = res[:msg]
+    end
+
+    def populate_user!(res)
+      res['accounts'].each do |account|
+        if self.accounts.none? { |h| h.id == account['_id'] }
+          self.accounts << Account.new(account)
+        end
+      end if res['accounts']
+
+      res['transactions'].each do |transaction|
+        if self.transactions.any? { |t| t == transaction['_id'] }
+          owned_transaction = self.transactions.find { |h| h == transaction['_id'] }
+          owned_transaction.new(transaction)
+        else
+          self.transactions << Transaction.new(transaction)
+        end
+      end if res['transactions']
+
+      self.pending_mfa_questions = {}
+      self.information = Information.new(res['info']) if res['info']
+      self.api_res = 'success'
+
+      # TODO: Remove the following line when upgrading to V-2
+      self.info.merge!(res['info']) if res['info']
+      # End TODO
+
+      self.access_token = res['access_token'].split[0]
+      self.type = res['access_token'].split[1]
+    end
+
+  end
+end

data/lib/old_plaid/version.rb

@@ -0,0 +1,3 @@
+module OldPlaid
+  VERSION = '1.7.1'
+end

data/old_plaid.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'old_plaid/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'old_plaid'
+  spec.version       = OldPlaid::VERSION
+  spec.authors       = ['Justin Crites']
+  spec.email         = ['crites.justin@gmail.com']
+  spec.summary       = 'Ruby bindings for OldPlaid'
+  spec.description   = 'Ruby gem wrapper for the OldPlaid API. Read more at the homepage, the wiki, or the plaid documentation.'
+  spec.homepage      = 'https://github.com/plaid/plaid-ruby'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~>3.1'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-stack_explorer'
+  spec.add_development_dependency 'webmock'
+end
+

data/spec/old_plaid_spec.rb

@@ -0,0 +1,263 @@
+# Authentication flow specs - returns OldPlaid::User
+
+describe OldPlaid do
+  let(:api_level) { raise "Define let(:api_level)" }
+  let(:username)  { raise "Define let(:username)" }
+  let(:password)  { raise "Define let(:password)" }
+  let(:type)      { raise "Define let(:type)" }
+  let(:pin)       { nil }
+  let(:options)   { nil }
+
+  describe '.add_user' do
+    let(:user) { OldPlaid.add_user api_level, username, password, type, pin, options }
+
+    context 'with correct credentials for single user auth' do
+      let(:username)  { 'plaid_test' }
+      let(:password)  { 'plaid_good' }
+      let(:type)      { 'wells' }
+
+      context 'and "connect" level of api access' do
+        let(:api_level) { 'connect' }
+
+        it { expect(user.accounts).not_to be_empty }
+
+        context 'with webhook' do
+          let(:options) { { login_only: true, webhook: 'test.com/test.endpoint.aspx' } }
+          it { expect(user.accounts).not_to be_empty }
+        end
+
+        context 'when account is locked' do
+          let(:password) { 'plaid_locked' }
+
+          it 'raises a locked error' do
+            expect { user }.to raise_error(OldPlaid::RequestFailed) { |error|
+              expect(error.code).to eq(1205)
+            }
+          end
+        end
+
+        context 'with connection options' do
+          context 'when requests pending transactions from an institution' do
+            let(:options) { { pending: true } }
+            it { expect(user.accounts).not_to be_empty }
+          end
+
+          context 'when login only is true' do
+            let(:options) { { login_only: true } }
+            it { expect(user.accounts).not_to be_empty }
+          end
+
+          context 'sets a start date for transactions' do
+            let(:options) { { login_only: true, start_date: '10 days ago'} }
+            it { expect(user.accounts).not_to be_empty }
+          end
+
+          context 'sets an end date for transactions' do
+            let(:options) { { login_only: true, end_date: '10 days ago'} }
+            it { expect(user.accounts).not_to be_empty }
+          end
+
+          context 'sets start and end dates for transactions' do
+            let(:options) { { gte: "05/10/2014" , lte: "06/10/2014" } }
+            it { expect(user.transactions).not_to be_nil }
+          end
+
+          pending 'with JSON-encoded string for options'
+        end
+      end
+
+      context 'and "auth" level of api access' do
+        let(:api_level) { 'auth' }
+        it { expect(user.accounts.first.numbers).not_to be_empty }
+      end
+
+      context 'and "info" level of api access' do
+        let(:api_level) { 'info' }
+        it { expect(user.info).not_to be_empty }
+      end
+    end
+
+    context 'with incorrect credentials for single factor auth' do
+      # Set up correct credentials. Override with bad element
+      # within each context block
+      let(:username)  { 'plaid_test' }
+      let(:password)  { 'plaid_good' }
+      let(:type)      { 'wells' }
+
+      context 'at "auth" level api access' do
+        let(:api_level) { 'auth' }
+
+        context 'using incorrect password' do
+          let(:password) { 'plaid_bad' }
+          it { expect { user }.to raise_error(OldPlaid::RequestFailed, 'invalid credentials') }
+        end
+
+        context 'using incorrect username' do
+          let(:username) { 'plaid_bad' }
+          it { expect { user }.to raise_error(OldPlaid::RequestFailed, 'invalid credentials') }
+        end
+      end
+
+      context 'at "connect" level api access' do
+        let(:api_level) { 'connect' }
+
+        context 'using incorrect password' do
+          let(:password) { 'plaid_bad' }
+          it { expect { user }.to raise_error(OldPlaid::RequestFailed, 'invalid credentials') }
+        end
+
+        context 'using incorrect username' do
+          let(:username) { 'plaid_bad' }
+          it { expect { user }.to raise_error(OldPlaid::RequestFailed, 'invalid credentials') }
+        end
+      end
+
+      context 'at "info" level api access' do
+        let(:api_level) { 'info' }
+
+        context 'using incorrect password' do
+          let(:password) { 'plaid_bad' }
+          it { expect { user }.to raise_error(OldPlaid::RequestFailed, 'invalid credentials') }
+        end
+
+        context 'using incorrect username' do
+          let(:username) { 'plaid_bad' }
+          it { expect { user }.to raise_error(OldPlaid::RequestFailed, 'invalid credentials') }
+        end
+      end
+    end
+
+    context 'when institution requires PIN' do
+      let(:api_level) { 'connect' }
+      let(:username)  { 'plaid_test' }
+      let(:password)  { 'plaid_good' }
+      let(:type)      { 'usaa' }
+
+      context 'using correct PIN' do
+        let(:pin) { '1234' }
+        it { expect(user.api_res).to eq 'Requires further authentication' }
+      end
+
+      context 'using incorrect PIN' do
+        let(:pin) { '0000' }
+        it { expect { user }.to raise_error(OldPlaid::RequestFailed, 'invalid pin') }
+      end
+    end
+
+    context 'when institution requires MFA' do
+      let(:api_level) { 'connect' }
+      let(:username)  { 'plaid_test' }
+      let(:password)  { 'plaid_good' }
+      let(:type)      { 'bofa' }
+
+      context 'with only standard credentials' do
+        it { expect(user.api_res).to eq 'Requires further authentication' }
+      end
+
+      context 'with options' do
+        context 'with webhook' do
+          let(:options) { { login_only: true, webhook: 'test.com/test.endpoint.aspx' } }
+          it { expect(user.api_res).to eq 'Requires further authentication' }
+        end
+
+        context 'requests a list of options for code based MFA' do
+          let(:type) { 'citi' }
+          let(:options) { { list: true } }
+
+          it { expect(user.pending_mfa_questions).not_to be_nil }
+        end
+      end
+    end
+  end
+
+  describe '.set_user' do
+    subject { OldPlaid.set_user(access_token) }
+    let(:access_token) { 'test' }
+
+    it { expect(subject.access_token).to eq(access_token)}
+
+    context 'gets a valid user with accounts and transactions' do
+      let(:user) { OldPlaid.set_user('test_wells',['connect']) }
+      it { expect(user.transactions).not_to be_empty }
+    end
+
+    context 'gets a valid user with accounts' do
+      let(:user) { OldPlaid.set_user('test_wells',['auth']) }
+      it { expect(user.accounts).not_to be_empty }
+    end
+
+    #TODO: Fully vet the info api endpoint for the beta functions before adding this as a supported function.
+    pending 'need to vet the info api endpoint' do
+      context 'gets a valid user with info' do
+        let(:user) { OldPlaid.set_user('test_wells',['info']) }
+        it { expect(user.accounts).to be_truthy}
+      end
+
+      context 'gets a fully validated user with all access granted' do
+        let(:user) { OldPlaid.set_user('test_wells', ['connect', 'info', 'auth']) }
+        it { expect(user.transactions).to be_truthy}
+      end
+    end
+  end
+
+  describe '.exchange_token' do
+    subject { OldPlaid.exchange_token('test,chase,connected', 'QPO8Jo8vdDHMepg41PBwckXm4KdK1yUdmXOwK') }
+
+    it { expect(subject.access_token).to eql('test_chase') }
+  end
+
+  describe '.transactions' do
+    subject { OldPlaid.transactions(access_token, options) }
+    let(:access_token) { 'test_wells' }
+    let(:options)      { nil }
+
+    context 'without options' do
+      it 'returns all accounts' do
+        expect(subject.accounts).not_to be_empty
+      end
+
+      it 'returns all transactions' do
+        expect(subject.transactions).not_to be_empty
+      end
+    end
+
+    context 'when filtering by account' do
+      let(:options) { { account: account } }
+      let(:account) { 'QPO8Jo8vdDHMepg41PBwckXm4KdK1yUdmXOwK' }
+
+      it 'returns a subset of transactions' do
+        expect(subject.transactions.size).to eql(2)
+      end
+
+      it 'return only transactions from the requested account' do
+        expect(subject.transactions.map(&:account).uniq).to eql([account])
+      end
+    end
+
+    context 'when filtering by date' do
+      let(:options) { { gte: "2014-07-24", lte: "2014-07-25" } }
+
+      it 'returns a subset of transactions' do
+        expect(subject.transactions.size).to eql(1)
+      end
+
+      it 'return only transactions from the requested date range' do
+        expect(subject.transactions.map(&:date).uniq).to eql(['2014-07-24'])
+      end
+    end
+
+    context 'when filtering by account and date' do
+      let(:options) { { account: account , gte: "2014-07-24", lte: "2014-07-25" } }
+      let(:account) { 'XARE85EJqKsjxLp6XR8ocg8VakrkXpTXmRdOo' }
+
+      it 'returns a subset of transactions' do
+        expect(subject.transactions.size).to eql(1)
+      end
+
+      it 'returns only transactions from the requested account and date range' do
+        expect(subject.transactions.map(&:date).uniq).to eql(['2014-07-24'])
+        expect(subject.transactions.map(&:account).uniq).to eql([account])
+      end
+    end
+  end
+end