plaid 1.4.3 → 1.5.0

data/lib/plaid/user/user.rb

@@ -1,173 +0,0 @@
-require_relative 'account/account'
-require_relative 'transaction/transaction'
-require_relative 'info/info'
-require 'plaid/util'
-require 'json'
-module Plaid
-  class Plaid::User
-    include Plaid::Util
-
-    # Define user vars
-    attr_accessor(:accounts, :transactions, :access_token, :type, :permissions, :api_res, :pending_mfa_questions, :info, :information)
-
-    def initialize
-      self.accounts = [], self.transactions = [], self.permissions = [], self.access_token = '', self.api_res = '', self.info = {}, self.information = Information.new
-    end
-
-    # Instantiate a new user with the results of the successful API call
-    # Build an array of nested accounts, and return self if successful
-    def new(res,api_level=nil)
-      build_user(res,api_level)
-    end
-
-    def mfa_authentication(auth,type=nil)
-      type = self.type if type.nil?
-      auth_path = self.permissions.last + '/step'
-      res = Plaid.post(auth_path,{mfa:auth,access_token:self.access_token,type:type})
-      self.accounts = [], self.transactions = []
-      build_user(res)
-    end
-
-    def select_mfa_method(selection,type=nil)
-      type = self.type if type.nil?
-      auth_path = self.permissions.last + '/step'
-      res = Plaid.post(auth_path,{options:{send_method: selection}.to_json, access_token:self.access_token,type:type})
-      build_user(res,self.permissions.last)
-    end
-
-    def get_auth
-      if self.permissions.include? 'auth'
-        res = Plaid.post('auth/get',{access_token:self.access_token})
-        build_user(res)
-      else
-        false
-      end
-    end
-
-    def get_connect(options=nil)
-      if self.permissions.include? 'connect'
-        payload = {access_token:self.access_token}
-        payload.merge!(options) if options
-        res = Plaid.post('connect/get',payload)
-        build_user(res)
-      else
-        false
-      end
-    end
-
-    def get_info
-      if self.permissions.include? 'info'
-        res = Plaid.secure_get('info',self.access_token)
-        build_user(res)
-      else
-        false
-      end
-    end
-
-    def update_info(username,pass,pin=nil)
-      if self.permissions.include? 'info'
-        payload = {username:username,password:pass,access_token:self.access_token}
-        payload.merge!({pin:pin}) if pin
-        res = Plaid.patch('info',payload)
-        puts res
-        build_user(res)
-      else
-        false
-      end
-    end
-
-    def update_balance
-      res = Plaid.post('balance',{access_token:self.access_token})
-      build_user(res)
-    end
-
-    def upgrade(api_level=nil)
-      if api_level.nil?
-        api_level = 'auth' unless self.permissions.include? 'auth'
-        api_level = 'connect' unless self.permissions.include? 'connect'
-      end
-      res = Plaid.post('upgrade',{access_token:self.access_token,upgrade_to:api_level})
-      self.accounts = [], self.transactions = []
-      build_user(res)
-    end
-
-    def delete_user
-      Plaid.delete('info',{access_token:self.access_token})
-    end
-
-    protected
-
-    def build_user(res,api_level=nil)
-      begin
-        if res[:msg].nil?
-          populate_user(self,res,api_level)
-          clean_up_user(self)
-        else
-          set_mfa_request(self,res,api_level)
-        end
-      rescue => e
-        error_handler(e)
-      else
-        self
-      end
-    end
-
-    # Instantiate and build a new account object, return this to the accounts array
-    def new_account(res)
-      account = Account.new
-      account.new(res)
-    end
-
-    # Instantiate and build a new account object, return this to the accounts array
-    def new_transaction(res)
-      transaction = Transaction.new
-      transaction.new(res)
-    end
-
-    private
-
-    def clean_up_user(user)
-      user.accounts.reject! { |c| !c.instance_of? Plaid::Account }
-      user
-    end
-
-    def set_mfa_request(user,res,api_level)
-      user.access_token = res[:body]['access_token']
-      user.pending_mfa_questions = res[:body]
-      user.api_res = res[:msg]
-      user.permissions << api_level unless self.permissions.include? api_level && api_level.nil?
-    end
-
-    def populate_user(user,res,api_level)
-      res['accounts'].each do |account|
-        if user.accounts.any? { |h| h == account['_id'] }
-          owned_account = user.accounts.find { |h| h == account['_id'] }
-          owned_account.new(account)
-        else
-          user.accounts << new_account(account)
-        end
-      end if res['accounts']
-
-      res['transactions'].each do |transaction|
-        if user.transactions.any? { |t| t == transaction['_id'] }
-          owned_transaction = user.transactions.find { |h| h == transaction['_id'] }
-          owned_transaction.new(transaction)
-        else
-          user.transactions << new_transaction(transaction)
-        end
-      end if res['transactions']
-
-      user.permissions << api_level unless user.permissions.include? api_level && api_level.nil?
-      user.pending_mfa_questions = ''
-      user.information.update_info(res['info']) if res['info']
-      user.api_res = 'success'
-
-      # TODO: Remove the following line when upgrading to V-2
-      user.info.merge!(res['info']) if res['info']
-      # End TODO
-      user.access_token = res['access_token'].split[0]
-      user.type = res['access_token'].split[1]
-    end
-
-  end
-end

data/lib/plaid/util.rb

@@ -1,120 +0,0 @@
-require 'net/http'
-require 'json'
-require 'uri'
-module Plaid
-  module Util
-
-    def post(path,options={})
-      uri = build_uri(path)
-      options.merge!({client_id: self.instance_variable_get(:'@customer_id') ,secret: self.instance_variable_get(:'@secret')})
-      res = Net::HTTP.post_form(uri,options)
-      parse_response(res)
-    end
-
-    def get(path,id=nil)
-      uri = build_uri(path,id)
-      res = Net::HTTP.get(uri)
-      parse_get_response(res)
-    end
-
-    def secure_get(path,access_token,options={})
-      uri = build_uri(path)
-      options.merge!({access_token:access_token})
-      req = Net::HTTP::Get.new(uri)
-      req.body = URI.encode_www_form(options) if options
-      req.content_type = 'multipart/form-data'
-      res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme == 'https') { |http| http.request(req) }
-      parse_response(res)
-    end
-
-    def patch(path,options={})
-      uri = build_uri(path)
-      options.merge!({client_id: self.instance_variable_get(:'@customer_id') ,secret: self.instance_variable_get(:'@secret')})
-      req = Net::HTTP::Patch.new(uri)
-      req.body = URI.encode_www_form(options) if options
-      req.content_type = 'multipart/form-data'
-      res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme == 'https') { |http| http.request(req) }
-      parse_response(res)
-    end
-
-    def delete(path,options={})
-      uri = build_uri(path)
-      options.merge!({client_id: self.instance_variable_get(:'@customer_id') ,secret: self.instance_variable_get(:'@secret')})
-      req = Net::HTTP::Delete.new(uri)
-      req.body = URI.encode_www_form(options) if options
-      req.content_type = 'multipart/form-data'
-      Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme == 'https') { |http| http.request(req) }
-    end
-
-    def error_handler(err,res=nil)
-      case err
-        when 'Bad Request'
-          puts res.body
-          raise 'The request was malformed. Did you check the API docs?'
-        when 'Unauthorized'
-          raise 'Access denied: Try using the correct credentials.'
-        when 'Request Failed'
-          raise 'Request Failed'
-        when 'Not Found'
-          raise 'Not Found'
-        when 'Institution not supported'
-          raise 'Institution not supported'
-        when 'Corrupted token'
-          raise 'It appears that the access token has been corrupted'
-        else
-          raise err
-      end
-    end
-
-    protected
-
-    def build_uri(path,option=nil)
-      path = path + '/' + option unless option.nil?
-      URI.parse(self.instance_variable_get(:'@environment_location') + path)
-    end
-
-    private
-
-    def parse_response(res)
-      body = JSON.parse(res.body)
-      case res.code.delete('.').to_i
-        when 200
-          return body
-        when 201
-          return { msg: 'Requires further authentication', body: body}
-        when 400
-          error_handler('Bad Request',res)
-        when 401
-          error_handler('Institution not supported',res) if body['code'] == 1108
-          error_handler('Corrupted token',res) if body['code'] == 1105
-          error_handler('Not Found',res) if body['code'] == 1501
-          error_handler('Unauthorized',res)
-        when 402
-          return {msg: 'User account is locked', body: body} if body['code'] == 1205
-          error_handler('Request Failed', res)
-        when 404
-          error_handler('Not Found',res)
-        else
-          error_handler('Server Error',res)
-      end
-    end
-
-    def parse_get_response(res)
-      body = JSON.parse(res)
-      if body.class == Array
-        body
-      else
-        if body['code'].nil?
-          body
-        else
-          if body['code'] == 1301 || body['code'] == 1401 || body['code'] == 1501 || body['code'] == 1601
-            error_handler('Not Found',body)
-          else
-            body
-          end
-        end
-      end
-    end
-
-  end
-end

data/spec/add_user_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper.rb'
-# Authentication flow specs - returns Plaid::User
-describe '.add_user' do
-
-  Plaid.config do |p|
-    p.customer_id = 'test_id'
-    p.secret = 'test_secret'
-    p.environment_location = 'https://tartan.plaid.com/'
-  end
-
-  context 'has correct credentials for single factor auth, authenticates to the connect level of api access' do
-    user = Plaid.add_user('connect','plaid_test','plaid_good','wells')
-    it { expect(user.accounts.empty?).to be_falsey }
-  end
-
-  context 'has correct credentials for single factor auth, authenticates to the auth level of api access' do
-    user = Plaid.add_user('auth','plaid_test','plaid_good','wells')
-    it { expect(user.accounts[0].numbers.nil?).to be_falsey }
-  end
-
-  context 'has correct credentials for single factor auth, authenticates to the info level of api access' do
-    user = Plaid.add_user('info','plaid_test','plaid_good','wells')
-    it { expect(user.info).to be_truthy }
-  end
-
-  context 'has correct username, but incorrect password for single factor auth under auth level of api access' do
-    it { expect{Plaid.add_user('auth','plaid_test','plaid_bad','wells')}.to raise_error }
-  end
-
-  context 'has incorrect username under auth level of api access' do
-    it { expect{Plaid.add_user('auth','plaid_bad','plaid_bad','wells')}.to raise_error }
-  end
-
-  context 'has correct username, but incorrect password for single factor auth under connect level of api access' do
-    it { expect{Plaid.add_user('connect','plaid_test','plaid_bad','wells')}.to raise_error }
-  end
-
-  context 'has incorrect username under connect level of api access' do
-    it { expect{Plaid.add_user('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
-  end
-
-  context 'has correct username, but incorrect password for single factor auth under info level of api access' do
-    it { expect{Plaid.add_user('info','plaid_test','plaid_bad','wells')}.to raise_error }
-  end
-
-  context 'has incorrect username under info level of api access' do
-    it { expect{Plaid.add_user('info','plaid_bad','plaid_bad','wells')}.to raise_error }
-  end
-
-  context 'enters pin for extra parameter authentication required by certain institutions' do
-    user = Plaid.add_user('connect','plaid_test','plaid_good','usaa','1234')
-    it { expect(user.api_res).to eq 'Requires further authentication' }
-  end
-
-  context 'enters incorrect pin for extra parameter authentication required by certain institutions' do
-    it { expect{Plaid.add_user('connect','plaid_test','plaid_good','usaa','0000')}.to raise_error }
-  end
-
-  context 'has to enter MFA credentials' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_good','bofa')
-    it { expect(user.api_res).to eq 'Requires further authentication' }
-  end
-
-  context 'enters correct information with locked account' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_locked','wells')
-    it { expect(user.api_res).to eq 'User account is locked' }
-  end
-
-  context 'enters webhook option as part of standard call' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_good','wells',{login_only: true, webhook: 'test.com/test.endpoint.aspx'})
-    it { expect(user.accounts.empty?).to be_falsey }
-  end
-
-  context 'enters webhook option as part of mfa required institution authentication' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_good','bofa',{login_only: true, webhook: 'test.com/test.endpoint.aspx'})
-    it { expect(user.api_res).to eq 'Requires further authentication' }
-  end
-
-  context 'requests pending transactions from an institution' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_good','wells',{pending: true})
-    it { expect(user.accounts.empty?).to be_falsey }
-  end
-
-  context 'sets the login only option to true' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_good','wells',{login_only:true})
-    it { expect(user.accounts.empty?).to be_falsey }
-  end
-
-  context 'requests a list of options for code based MFA' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_good','citi',{list: true})
-    it { expect(user.pending_mfa_questions.nil?).to be_falsey }
-  end
-
-  context 'sets a start date for transactions' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_good','wells',{login_only:true, start_date:'10 days ago'})
-    it { expect(user.accounts.empty?).to be_falsey }
-  end
-
-  context 'sets an end date for transactions' do
-    user = Plaid.add_user('connect','plaid_test', 'plaid_good','wells',{login_only:true, end_date: '10 days ago'})
-    it { expect(user.accounts.empty?).to be_falsey }
-  end
-
-  context 'sets start and end dates for transactions' do
-    user = Plaid.add_user('connect','plaid_test','plaid_good','wells',"{'gte':'05/10/2014' , 'lte':'06/10/2014'}")
-    it{ expect(user.transactions).to be_truthy }
-  end
-
-  context 'sets a user with an existing access token' do
-    user = Plaid.set_user('test')
-    it{ expect(user.access_token).to eq('test')}
-  end
-end