plaid_rails 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61f6da3ef8adaecdfc317658e67984c85e41523b
-  data.tar.gz: 78da897a2aa4f7d77bd1fdb7e5aa7b10e9dabdd6
+  metadata.gz: 1be2e2ff076fc81d6744b9b9ad21713f25ee03f6
+  data.tar.gz: 1f97d8a175a1de3e132de0ef53483d439cd2b347
 SHA512:
-  metadata.gz: 193ce2a12853307505f295dbfa264baca9e95c8d1a04392e2c89546ed7d55d0173ea409f663bbce241c108a4a86abaa961163e68a120c74123ca03f167b90124
-  data.tar.gz: d4e424a09d944f832db08a3b664021ad25de8de0c690c22629ee3aef064b70ef9b6b752c146cc772f61badcd8b8eae2f7082034dba4e5346a67d8ae8ddf34e47
+  metadata.gz: 3606d4d8a413950fd005a3eb334e89649ac85ace2f686caf59d05bd9faf30e9ca6ad1e785a4b45a96492cb47dc89fd2acfb864b9b5d7170c9e49c1c238196c8a
+  data.tar.gz: bbbfa8aaa1ec946e9f8cab2acd7fd3c3aaad7656fa340f3fdc45c357a6b1b4366ac45f4587e11c64fe4ef077dc7667e493f61a3e19eb2777dba9c4da59951ee2

data/README.md

@@ -73,3 +73,11 @@ The plaid webhooks runs subscribers for to process transactions and report error
 
 Update the PlaidRails.configuration.webhook with  the address of the webhook url.  The route is `plaid/webhook`
 i.e. http(s)://my.app.com/plaid/webhooks 
+
+### Testing
+To run the tests you need to set the PLAID credentials in environment variables.
+```bash
+export PLAID_CLIENT_ID='your client_id'
+export PLAID_SECRET='your secret'
+export PLAID_PUBLIC_KEY='your public_key'
+```

data/app/assets/javascripts/plaid_rails/link.js

@@ -1,24 +1,33 @@
+function getPublicToken(access_token) {
+    $.post('/plaid/create_token',
+            {access_token: access_token},
+            function (data, status, xhr) {
+                return data.public_token;
+            },
+            'json'
+            );
+}
 function getPlaid(plaidData) {
     var url = null;
-    var token = plaidData.data('token');
+    var access_token = plaidData.data('access-token');
     var env = plaidData.data('env');
-    if (typeof token === 'undefined') {
+    var token;
+    if (typeof access_token === 'undefined') {
         url = '/plaid/authenticate';
         token = null;
     } else {
         url = '/plaid/update';
-    }
-    // set token for test environment
-    if (env === 'tartan' && typeof plaidData.data('type') !== 'undefined') {
-        token = 'test,' + plaidData.data('type') + ',connected'
+        token = getPublicToken(access_token);
     }
 
     var linkHandler = Plaid.create({
         env: env,
+        apiVersion: 'v2',
         clientName: plaidData.data('client-name'),
         key: plaidData.data('key'),
-        product: 'connect',
+        product: 'transactions',
         webhook: plaidData.data('webhook'),
+        token: token,
         onLoad: function () {
             // The Link module finished loading.
         },
@@ -32,11 +41,12 @@ function getPlaid(plaidData) {
                 url: url,
                 data: {
                     public_token: public_token,
-                    name: metadata.institution.name,
-                    type: metadata.institution.type,
+                    access_token: plaidData.data('access-token'),
+                    name: metadata.account.name,
+                    type: metadata.account.type,
                     owner_type: plaidData.data('owner-type'),
                     owner_id: plaidData.data('owner-id'),
-                    number: plaidData.data('number')
+                    number: metadata.account.mask
                 }
             });
         },
@@ -50,10 +60,10 @@ function getPlaid(plaidData) {
 $(document).on("click", '#plaidLinkButton', function () {
     var plaidData = $(this);
     linkHandler = getPlaid(plaidData);
-    var plaidType = plaidData.data('type')
+    var plaidType = plaidData.data('type');
     //open handler for the institution
     if (typeof plaidType === 'undefined') {
-        linkHandler.open();
+    linkHandler.open();
     } else {
         linkHandler.open(plaidType);
     }

data/app/controllers/plaid_rails/accounts_controller.rb

@@ -9,10 +9,14 @@ module PlaidRails
     
     # display list of accounts for authenticated user
     def new
-      account_params["access_token"]
-      @user = Plaid::User.load(:connect, account_params["access_token"])
-      @user.transactions
-      @plaid_accounts = @user.accounts
+      client = Plaid::Client.new(env: PlaidRails.env,
+                  client_id: PlaidRails.client_id,
+                  secret: PlaidRails.secret,
+                  public_key: PlaidRails.public_key)
+
+      response = client.accounts.get(account_params["access_token"])
+      @plaid_accounts = response.accounts
+      
     end
     
     #create new bank account and return all the accounts for the owner
@@ -33,7 +37,7 @@ module PlaidRails
     
     # Never trust parameters from the scary internet, only allow the white list through.
     def account_params
-      params.require(:account).permit(:token,:access_token, :type,:name,
+      params.require(:account).permit(:access_token, :type,:name,
         :owner_id,:owner_type, :transactions_start_date, account_ids:[])
     end
   end

data/app/controllers/plaid_rails/link_controller.rb

@@ -3,44 +3,49 @@ require_dependency "plaid_rails/application_controller"
 module PlaidRails
   class LinkController < ApplicationController
 
+    # /plaid/authenticate
     def authenticate
       begin
-        @exchange_token = Plaid::User.exchange_token(link_params[:public_token])
-
+        client = Plaid::Client.new(env: PlaidRails.env,
+          client_id: PlaidRails.client_id,
+          secret: PlaidRails.secret,
+          public_key: PlaidRails.public_key)
+        @exchange_token = client.item.public_token.exchange(link_params[:public_token])
         @params = link_params.merge!(token: link_params[:public_token])
         
       rescue => e
         Rails.logger.error "Error: #{e}"
-        Rails.logger.error e.backtrace.join("\n")
         render text: e.message, status: 500
       end
     end
     
     # updates the access token after changing password with institution  
+    # /plaid/update
     def update
       begin
-        exchange_token = Plaid::User.exchange_token(link_params[:public_token])
-        
-        # find old access_token
-        old_access_token = PlaidRails::Account.find_by(owner_type: link_params[:owner_type],
-        owner_id: link_params[:owner_id],number: link_params[:number]).access_token
-        
-        # find all plaid_accounts with old access_token 
-        accounts = PlaidRails::Account.where(owner_type: link_params[:owner_type],
-        owner_id: link_params[:owner_id], access_token: old_access_token)
-      
-        # update found accounts with new token.
-        accounts.update_all(access_token: exchange_token.access_token, 
-            transactions_start_date: Date.today)
-    
         # get all accounts to display back to user.
         @plaid_accounts = PlaidRails::Account.where(owner_type: link_params[:owner_type],
-        owner_id: link_params[:owner_id])
+          owner_id: link_params[:owner_id])
       
         flash[:success]="You have successfully updated your account(s)"
       rescue => e
         Rails.logger.error "Error: #{e}"
-        render text: e.message, status: 500
+        render json: e.message, status: 500
+      end
+    end
+    
+    # creates a new public token
+    # /plaid/create_token
+    def create_token
+      client = Plaid::Client.new(env: PlaidRails.env,
+        client_id: PlaidRails.client_id,
+        secret: PlaidRails.secret,
+        public_key: PlaidRails.public_key)
+      if link_params['access_token']
+        response = client.item.public_token.create(link_params['access_token'])
+        render json: {public_token: response['public_token']}.to_json
+      else
+        render json: {error: 'missing access_token'}.to_json, status: 500
       end
     end
     

data/app/controllers/plaid_rails/webhooks_controller.rb

@@ -3,13 +3,14 @@ module PlaidRails
     skip_before_filter :verify_authenticity_token
     
     def create
-      @webhook = PlaidRails::Webhook.create!(webhook_params)
-      render json: @webhook
+      webhook = PlaidRails::Webhook.create!(webhook_params)
+      render json: webhook
     end
     
     private
     def webhook_params
-      params.require(:webhook).permit(:code, :message, :access_token)
+      params.require(:webhook).permit(:webhook_type, :webhook_code,:error, 
+        :item_id, :new_transactions, :removed_transactions, :code, :message,:access_token  )
     end
   end
 end

data/app/models/plaid_rails/account.rb

@@ -8,7 +8,6 @@ module PlaidRails
     validates :plaid_id, presence: true
     validates :name, presence: true
     validates :access_token, presence: true
-    validates :plaid_type, presence: true
     
     private
     
@@ -25,10 +24,13 @@ module PlaidRails
     def delete_connect
       begin
         Rails.logger.info "Deleting Plaid User with token #{token_last_8}"
-        user = Plaid::User.load(:connect, my_token)
+        client = Plaid::Client.new(env: PlaidRails.env,
+          client_id: PlaidRails.client_id,
+          secret: PlaidRails.secret,
+          public_key: PlaidRails.public_key)
         # skip delete if there are no transactions
-        if user.transactions.any?
-          user.delete 
+        if client.transactions.any?
+          client.item.remove(access_token)
           Rails.logger.info "Deleted Plaid User with token #{token_last_8}"
         end
       rescue  => e

data/app/models/plaid_rails/webhook.rb

@@ -1,9 +1,13 @@
 module PlaidRails
   class Webhook < ActiveRecord::Base
     
-    validates :code, presence: true
-    validates :message, presence: true
-    validates :access_token, presence: true
+    #    validates :code, presence: true
+    #    validates :message, presence: true
+    #    validates :access_token, presence: true
+    #    validates :webhook_type, presence: true
+    #    validates :webhook_code, presence: true
+    #    validates :item_id, presence: true
+    serialize :removed_transactons, Array
     after_save :event
    
     private

data/app/services/plaid_rails/create_account_service.rb

@@ -4,25 +4,30 @@ module PlaidRails
     # creates a new plaid_rails_account for each account the user has selected
     def self.call(account_params)
       account_params["account_ids"].each  do |id|
-        # set Plaid::User
-        user = Plaid::User.load(:connect, account_params["access_token"])
-        # get all the info, make plaid /connect/get call
-        user.transactions
+        # Create the Plaid Client
+        client = Plaid::Client.new(env: PlaidRails.env,
+                  client_id: PlaidRails.client_id,
+                  secret: PlaidRails.secret,
+                  public_key: PlaidRails.public_key)
         #find the account by account_id 
-        account = user.accounts.find{|a| a.id==id}
+        account = client.accounts.get(account_params["access_token"]).accounts.find{|a| a.account_id==id}
+        response =  client.item.get(account_params["access_token"])
+        item = response.item
+        response = client.institutions.get_by_id(item['institution_id'])
+        institution = response.institution
         PlaidRails::Account.create!(
           access_token: account_params["access_token"], 
-          token: account_params["token"],
-          plaid_type: account_params["type"],
+          plaid_type: item.institution_id,
           name: account.name,
-          bank_name: Plaid::Institution.get(account_params["type"]).name,
-          number: account.meta["number"],
+          bank_name: institution.name,
+          number: account.mask,
           owner_id: account_params["owner_id"],
           owner_type: account_params["owner_type"],
-          available_balance: account.available_balance,
-          current_balance: account.current_balance,
+          available_balance: account.balances.available,
+          current_balance: account.balances.current,
           transactions_start_date: account_params["transactions_start_date"],
-          plaid_id: id
+          plaid_id: id,
+          item_id: item.item_id
         ) unless PlaidRails::Account.exists?(plaid_id: id)
       end
       

data/app/views/plaid_rails/accounts/new.html.erb

@@ -9,8 +9,8 @@
   <%= hidden_field_tag "account[owner_type]", params["owner_type"] %>
   <%= label_tag "start_date" %> <%= date_field_tag "account[transactions_start_date]" %>
   <% @accounts.each_with_index do |account,index| %>
-    <%= check_box_tag "account[account_ids][]", account.id,nil,{id: "account_account_ids_#{index}"}%> 
-    <label for="account_account_ids_<%=index%>"> <%= "#{account.meta["name"]} - #{account.meta["number"]}"%></label><br/>
+    <%= check_box_tag "account[account_ids][]", account.account_idid,nil,{id: "account_account_ids_#{index}"}%> 
+    <label for="account_account_ids_<%=index%>"> <%= "#{account.name} - #{account.mask}"%></label><br/>
   <%end%>
 
   <%= submit_tag "Save", :class=>"button small" %>

data/app/views/plaid_rails/link/_auth.html.erb

@@ -3,7 +3,7 @@
 
 <div id="plaid-data"
      data-client-name="<%= client_name %>"
-     data-env="<%= Rails.env.production? ? "production" : "tartan"%>"
+     data-env="<%= Rails.env.production? ? "production" : "sandbox"%>"
      data-key="<%=  PlaidRails.public_key %>"
      data-webhook="<%=  PlaidRails.webhook %>"
      data-owner-type="<%=  owner.class.name %>"

data/config/routes.rb

@@ -5,5 +5,5 @@ PlaidRails::Engine.routes.draw do
   match '/webhooks', to: 'webhooks#create',   via: :post
   match '/authenticate', to: "link#authenticate", via: :post
   match '/update', to: "link#update", via: :post
-
+  match 'create_token', to: 'link#create_token', via: :post
 end

data/db/migrate/20180617232228_api_update.rb

@@ -0,0 +1,12 @@
+class ApiUpdate < ActiveRecord::Migration
+  def change
+    add_column :plaid_rails_webhooks, :item_id, :string
+    add_column :plaid_rails_webhooks, :webhook_type, :string
+    add_column :plaid_rails_webhooks, :webhook_code, :string
+    add_column :plaid_rails_webhooks, :error, :string
+    add_column :plaid_rails_webhooks, :new_transactions, :integer
+    add_column :plaid_rails_webhooks, :removed_transactions, :text
+    add_column :plaid_rails_accounts, :item_id, :string
+    remove_column :plaid_rails_accounts, :token
+  end
+end

data/lib/generators/plaid_rails/templates/initializer.rb

@@ -1,12 +1,10 @@
-Plaid.config do |p|
-  p.customer_id = Rails.application.secrets[:plaid][:customer_id]
-  p.secret =  Rails.application.secrets[:plaid][:secret]
-  p.environment_location = Rails.env.production? ? 'https://api.plaid.com/' : 'https://tartan.plaid.com/'
-end
+
 PlaidRails.configure do |config|
+  config.client_id = Rails.application.secrets[:plaid][:client_id]
+  config.secret = Rails.application.secrets[:plaid][:secret]
   config.public_key =  Rails.application.secrets[:plaid][:public_key]
   config.longtail = true
-  config.env =  Rails.env.production? ? "production" : "tartan"
+  config.env =  Rails.env.production? ? "production" : "sandbox"
   config.webhook = 'https://my.app.com/plaid/webhooks'
   
   # https://plaid.com/docs/#webhook

data/lib/plaid_rails.rb

@@ -5,7 +5,7 @@ require "plaid"
 module PlaidRails
   
   class << self
-    attr_accessor :customer_id,
+    attr_accessor :client_id,
       :secret,
       :environment_location,
       :public_key,

data/lib/plaid_rails/event.rb

@@ -12,16 +12,16 @@ module PlaidRails
       alias :setup :configure
       
       def instrument(event)
-        name = case event.code
-        when 0
+        name = case event.webhook_code
+        when 'INITIAL_UPDATE'
           "transactions.initial"
-        when 1
+        when 'HISTORICAL_UPDATE'
           "transactions.new"
-        when 2
+        when 'DEFAULT_UPDATE'
           "transactions.interval"
-        when 3
+        when 'TRANSACTIONS_REMOVED'
           "transactions.removed"
-        when 4
+        when 'WEBHOOK_UPDATE_ACKNOWLEDGED'
           "webhook.updated"
         else
           "plaid.error"

data/lib/plaid_rails/version.rb

@@ -1,3 +1,3 @@
 module PlaidRails
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/spec/controllers/plaid_rails/accounts_controller_spec.rb

@@ -4,8 +4,12 @@ module PlaidRails
   describe AccountsController do
     routes { PlaidRails::Engine.routes }
     let(:account){create(:account)}
-    let(:public_token){'test,wells,connected'}
-    let(:user){Plaid::User.load(:connect, 'test_wells').upgrade(:info)}
+    let(:public_token){create_public_token}
+    let(:client){Plaid::Client.new(env: PlaidRails.env,
+                  client_id: PlaidRails.client_id,
+                  secret: PlaidRails.secret,
+                  public_key: PlaidRails.public_key)}
+    let(:access_token){create_access_token}
     
     it "get index" do
       get :index, account:{owner_id: 1}
@@ -15,20 +19,21 @@ module PlaidRails
     end
       
     it "get new" do
-      get :new, account:{access_token: 'test_wells', name:'Wells Fargo', type: 'wells',
+      get :new, account:{access_token: access_token, name:'Wells Fargo', type: 'wells',
         owner_id: "1", owner_type: "User"}
       expect(response).to be_success
       expect(assigns(:plaid_accounts)).to_not be_nil
+      expect(assigns(:plaid_accounts).first.name).to eq('Plaid Checking')
     end
     
     it "can create" do
-      accounts = user.accounts.map{|a| a.id}
-      post :create, account: {access_token: 'test_wells', account_ids: accounts,
+      accounts = client.accounts.get(access_token).accounts.map{|a| a.account_id}
+      post :create, account: {access_token: access_token, account_ids: accounts,
         name:'Wells Fargo', type: 'wells', owner_id: "1", owner_type: "User",
         token: public_token}
       expect(response).to be_success
       expect(assigns(:plaid_accounts).size).to eq 4
-      expect(assigns(:plaid_accounts).first.bank_name).to eq 'Wells Fargo'
+      expect(assigns(:plaid_accounts).first.name).to  eq('Plaid Checking')
     end
     
     it "can destroy" do
@@ -36,13 +41,6 @@ module PlaidRails
       expect(response).to be_success
       expect(assigns(:plaid_account)).to eq account
     end
-    
-    #    it {
-    #      should permit(:access_token, :type,:name,:owner_id,:owner_type,:account_id).
-    #        for(:create, params: {access_token: 'test_wells', account_id: '1', 
-    #          name: 'name'})}
-    #    it {
-    #      should permit(:token, :type,:name,:owner_id,:owner_type).
-    #        for(:new, verb: :get, params: {access_token: 'test_wells'})}
+
   end
 end