plaid_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cfa957e3247b9dd795200f9e15eb2a775425adf7
+  data.tar.gz: ccaacbd3394200f6653ff4891584054e4760e4f5
+SHA512:
+  metadata.gz: 7c0d5802e0258f8e4115c1d3cb9295610934f2001f04408d7423984606f96b282fe8db52aee8052e84a9cf154348ba0578cb178fd698ae7cd7f4bf758272e11a
+  data.tar.gz: 8f2aa09ebfc55dfea10cd084f699293aaa49ed430c76cadd8ee246802cadb8c57fe235b78d8f911c527516f7f2b78e004552e94783c232bb985cbf60f5566bf8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 YOURNAME
+
+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/Rakefile

@@ -0,0 +1,29 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PlaidRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+require 'rspec/core'
+require 'rspec/core/rake_task'
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+task :default => :spec

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

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

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

@@ -0,0 +1,36 @@
+var plaidData = $("#plaid-data");
+var linkHandler = Plaid.create({
+    env: plaidData.data('env'),
+    clientName: plaidData.data('client-name'),
+    key: plaidData.data('key'),
+    product: 'connect',
+    webhook: plaidData.data('webhook'),
+    onLoad: function () {
+        // The Link module finished loading.
+    },
+    onSuccess: function (public_token, metadata) {
+        // Send the public_token to your app server here.
+        // The metadata object contains info about the institution the
+        // user selected and the account ID, if selectAccount is enabled.
+        $.ajax({
+            type: 'POST',
+            dataType: 'script',
+            url: '/plaid/authenticate',
+            data: {
+                public_token: public_token,
+                name: metadata.institution.name,
+                type: metadata.institution.type,
+                owner_type: plaidData.data('owner-type'),
+                owner_id: plaidData.data('owner-id')
+            }
+        });
+    },
+    onExit: function () {
+        // The user exited the Link flow.
+    }
+});
+// Trigger the authentication view
+$(document).on("click", '#plaidLinkButton', function () {
+    linkHandler.open();
+});
+

data/app/assets/javascripts/plaid_rails.js

@@ -0,0 +1 @@
+//= require_tree './plaid_rails'

data/app/assets/stylesheets/plaid_rails/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/plaid_rails/accounts_controller.rb

@@ -0,0 +1,39 @@
+require_dependency "plaid_rails/application_controller"
+
+module PlaidRails
+  class AccountsController < ApplicationController
+    
+    def index
+      @accounts =PlaidRails::Account.where(owner_id: account_params[:owner_id])
+    end
+    
+    # display list of accounts for authenticated user
+    def new
+      @user = Plaid.set_user(account_params[:access_token], ['auth'])
+      # Retrieve the user's accounts
+      @user.get('auth')
+      @accounts = @user.accounts
+    end
+    
+    #create new bank account and return all the accounts for the owner
+    def create
+      @accounts = PlaidRails::CreateAccountService.call(account_params)
+    end
+    
+    def update
+      
+    end
+    
+    def destroy
+      account = PlaidRails::Account.find(params[:id])
+      account.destroy
+    end
+    
+    private
+    
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def account_params
+      params.require(:account).permit(:access_token, :type,:name,:owner_id,:owner_type,account_ids:[])
+    end
+  end
+end

data/app/controllers/plaid_rails/application_controller.rb

@@ -0,0 +1,4 @@
+module PlaidRails
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/plaid_rails/link_controller.rb

@@ -0,0 +1,25 @@
+require_dependency "plaid_rails/application_controller"
+
+module PlaidRails
+  class LinkController < ApplicationController
+
+    def authenticate
+      begin
+        @exchange_token = Plaid.exchange_token(link_params[:public_token])
+
+        @params = link_params
+        
+      rescue => e
+        Rails.logger.error "Error: #{e}"
+        Rails.logger.error e.backtrace.join("\n")
+        render text: e.message, status: 500
+      end
+    end
+    
+    private
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def link_params
+      params.permit(:public_token, :type,:name,:owner_id,:owner_type)
+    end
+  end
+end

data/app/controllers/plaid_rails/webhooks_controller.rb

@@ -0,0 +1,15 @@
+module PlaidRails
+  class WebhooksController < ApplicationController
+    skip_before_filter :verify_authenticity_token
+    
+    def create
+      @webhook = PlaidRails::Webhook.create!(webhook_params)
+      render json: @webhook
+    end
+    
+    private
+    def webhook_params
+      params.require(:webhook).permit(:code, :message, :access_token)
+    end
+  end
+end

data/app/helpers/plaid_rails/application_helper.rb

@@ -0,0 +1,4 @@
+module PlaidRails
+  module ApplicationHelper
+  end
+end

data/app/models/plaid_rails/account.rb

@@ -0,0 +1,10 @@
+module PlaidRails
+  class Account < ActiveRecord::Base
+    belongs_to :owner, polymorphic: true, foreign_key: :owner_id
+    
+    validates :plaid_id, presence: true
+    validates :name, presence: true
+    validates :access_token, presence: true
+    validates :plaid_type, presence: true
+  end
+end

data/app/models/plaid_rails/webhook.rb

@@ -0,0 +1,14 @@
+module PlaidRails
+  class Webhook < ActiveRecord::Base
+    
+    validates :code, presence: true
+    validates :message, presence: true
+    validates :access_token, presence: true
+    after_save :event
+   
+    private
+    def event
+      PlaidRails::Event.instrument(self)
+    end
+  end
+end

data/app/services/plaid_rails/create_account_service.rb

@@ -0,0 +1,30 @@
+module PlaidRails
+  class CreateAccountService
+  
+    # 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.set_user(account_params["access_token"],['auth'])
+        #find the account by account_id 
+        account = user.accounts.find{|a| a.id==id}
+        
+        PlaidRails::Account.create!(
+          access_token: account_params["access_token"], 
+          plaid_type: account_params["type"],
+          name: account.name,
+          bank_name: account.meta["name"],
+          number: account.meta["number"],
+          owner_id: account_params["owner_id"],
+          owner_type: account_params["owner_type"],
+          available_balance: account.available_balance,
+          current_balance: account.current_balance,
+          plaid_id: id
+        ) unless PlaidRails::Account.exists?(plaid_id: id)
+      end
+        
+      PlaidRails::Account.where(owner_id: account_params["owner_id"], 
+        owner_type: account_params["owner_type"])
+    end
+  end
+end

data/app/views/layouts/plaid_rails/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>PlaidRails</title>
+  <%= stylesheet_link_tag    "plaid_rails/application", media: "all" %>
+  <%= javascript_include_tag "plaid_rails/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

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

@@ -0,0 +1 @@
+<%= render template: "index" %>

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

@@ -0,0 +1 @@
+account removed

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

@@ -0,0 +1,5 @@
+<h3>Accounts</h3>
+
+<% @accounts.each do |account| %>
+  <%=account.name%> <br/>
+<%end%>

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

@@ -0,0 +1,17 @@
+<h3>Select The Accounts To Link</h3>
+
+
+<%= form_tag "/plaid/accounts", method: "post", remote: true do %>
+  <%= hidden_field_tag "account[access_token]", params["access_token"] %>
+  <%= hidden_field_tag "account[name]", params["name"] %>
+  <%= hidden_field_tag "account[type]", params["type"] %>
+  <%= hidden_field_tag "account[owner_id]", params["owner_id"] %>
+  <%= hidden_field_tag "account[owner_type]", params["owner_type"] %>
+  <% @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/>
+  <%end%>
+
+  <%= submit_tag "Save", :class=>"button small" %>
+  <%= button_tag "Cancel" , :class=>"button small close"%>
+<%end%>

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

@@ -0,0 +1,14 @@
+<button id="plaidLinkButton" class="small">Link your Bank Account</button>
+
+
+<div id="plaid-data"
+     data-client-name="<%= client_name %>"
+     data-env="<%= Rails.env.production? ? "production" : "tartan"%>"
+     data-key="<%=  PlaidRails.public_key %>"
+     data-webhook="<%=  PlaidRails.webhook %>"
+     data-owner-type="<%=  owner.class.name %>"
+     data-owner-id="<%=  owner.id %>">
+</div>
+
+<%=javascript_include_tag "https://cdn.plaid.com/link/stable/link-initialize.js" %>
+<%=javascript_include_tag "plaid_rails/link.js" %>

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

@@ -0,0 +1,2 @@
+// override this js file with your own in your the own view in 
+// app/views/plaid_rails/link/authenticate.html.erb

data/app/views/plaid_rails/link/authenticate.js.erb

@@ -0,0 +1,5 @@
+// override this js file with your own in your the own view in 
+// app/views/plaid_rails/link/authenticate.js.erb
+
+console.log('success')
+alert('success')

data/config/routes.rb

@@ -0,0 +1,9 @@
+PlaidRails::Engine.routes.draw do
+  
+  resources :accounts
+    
+  match '/webhooks', to: 'webhooks#create',   via: :post
+  match '/authenticate', to: "link#authenticate", via: :post
+  
+
+end

data/db/migrate/20160214150149_create_plaid_rails_webhooks.rb

@@ -0,0 +1,12 @@
+class CreatePlaidRailsWebhooks < ActiveRecord::Migration
+  def change
+    create_table :plaid_rails_webhooks do |t|
+      t.integer :code 
+      t.string :message
+      t.string :access_token
+      t.text :params
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20160215155024_create_plaid_rails_accounts.rb

@@ -0,0 +1,22 @@
+class CreatePlaidRailsAccounts < ActiveRecord::Migration
+  def change
+    create_table :plaid_rails_accounts do |t|
+      t.string :access_token
+      t.string :plaid_type
+      t.string :name
+      t.string :bank_name
+      t.integer :number
+      t.string :plaid_id
+      t.string :owner_type
+      t.integer :owner_id
+      t.datetime :last_sync
+      t.decimal :current_balance, :precision => 10, :scale => 2
+      t.decimal :available_balance, :precision => 10, :scale => 2
+      t.string :error
+      t.timestamps
+    end
+    add_index :plaid_rails_accounts, :access_token
+    add_index :plaid_rails_accounts, :owner_id
+    add_index :plaid_rails_accounts, :plaid_id
+  end
+end

data/lib/plaid_rails/engine.rb

@@ -0,0 +1,21 @@
+module PlaidRails
+  class Engine < ::Rails::Engine
+    
+    isolate_namespace PlaidRails
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+    
+    initializer :append_migrations do |app|
+      unless app.root.to_s.match root.to_s
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
+    
+  end
+end

data/lib/plaid_rails/event.rb

@@ -0,0 +1,75 @@
+require "active_support/notifications"
+
+module PlaidRails
+  module Event
+    class << self
+      attr_accessor :adapter, :backend, :event_retriever, :namespace, :authentication_secret
+
+      def configure(&block)
+        raise ArgumentError, "must provide a block" unless block_given?
+        block.arity.zero? ? instance_eval(&block) : yield(self)
+      end
+      alias :setup :configure
+      
+      def instrument(event)
+        name = case event.code
+        when 0
+          "transactions.initial"
+        when 1
+          "transactions.new"
+        when 2
+          "transactions.interval"
+        when 3
+          "transactions.removed"
+        when 4
+          "webhook.updated"
+        else
+          "plaid.error"
+        end
+        backend.instrument namespace.call(name), event if event
+      end
+      
+      def subscribe(name, callable = Proc.new)
+        backend.subscribe namespace.to_regexp(name), adapter.call(callable)
+      end
+
+      def all(callable = Proc.new)
+        subscribe nil, callable
+      end
+
+      def listening?(name)
+        namespaced_name = namespace.call(name)
+        backend.notifier.listening?(namespaced_name)
+      end
+    end
+  
+    class Namespace < Struct.new(:value, :delimiter)
+      def call(name = nil)
+        "#{value}#{delimiter}#{name}"
+      end
+
+      def to_regexp(name = nil)
+        %r{^#{Regexp.escape call(name)}}
+      end
+    end
+
+    class NotificationAdapter < Struct.new(:subscriber)
+      def self.call(callable)
+        new(callable)
+      end
+
+      def call(*args)
+        payload = args.last
+        subscriber.call(payload)
+      end
+    end
+
+    class Error < StandardError; end
+    class UnauthorizedError < Error; end
+
+    self.adapter = NotificationAdapter
+    self.backend = ActiveSupport::Notifications
+    # self.event_retriever = lambda { |params| PlaidRails::Event.retrieve(params[:webhooks][:access_token]) }
+    self.namespace = Namespace.new("plaid_rails", ".")
+  end
+end

data/lib/plaid_rails/version.rb

@@ -0,0 +1,3 @@
+module PlaidRails
+  VERSION = "0.0.1"
+end

data/lib/plaid_rails.rb

@@ -0,0 +1,49 @@
+require "plaid_rails/engine"
+require "plaid_rails/event"
+require "plaid"
+
+module PlaidRails
+  
+  class << self
+    attr_accessor :customer_id,
+      :secret,
+      :environment_location,
+      :public_key,
+      :webhook,
+      :long_tail
+   
+    
+    def configure(&block)
+      raise ArgumentError, "must provide a block" unless block_given?
+      block.arity.zero? ? instance_eval(&block) : yield(self)
+    end
+    
+    def subscribe(name, callable = Proc.new)
+      PlaidRails::Event.subscribe(name, callable)
+    end
+    
+    def instrument(name, object)
+      PlaidRails::Event.backend.instrument( PlaidRails::Event.namespace.call(name), object)
+    end
+
+    def all(callable = Proc.new)
+      PlaidRails::Event.all(callable)
+    end
+    
+#    class Retriever
+#      def self.call(params)
+#        #return nil if StripeWebhook.exists?(stripe_id: params[:id])
+#        Webhook.create!(params: params)
+#        # event = Stripe::Event.retrieve(params[:id], { api_key: Payola.secret_key })
+#        #Payola.event_filter.call(event)
+#      end
+#    end
+    
+    def reset!
+      #PlaidRails::Event.event_retriever = Retriever
+      
+    end
+  end
+  
+  self.reset!
+end

data/lib/tasks/plaid_rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :plaid_rails do
+#   # Task goes here
+# end

data/spec/controllers/plaid_rails/accounts_controller_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module PlaidRails
+  describe AccountsController do
+    routes { PlaidRails::Engine.routes }
+    let(:account){create(:account)}
+    let(:public_token){'test,wells,connected'}
+    let(:user){Plaid.set_user('test_wells', ['auth'])}
+    
+    it "get index" do
+      get :index, account:{owner_id: 1}
+      expect(response).to be_success
+      expect(assigns(:accounts)).to eq [account]
+        
+    end
+      
+    it "get new" do
+      get :new, account:{access_token: 'test_wells', name:'Wells Fargo', type: 'wells',
+        owner_id: "1", owner_type: "User"}
+      expect(response).to be_success
+      expect(assigns(:accounts)).to_not be_nil
+    end
+    
+    it "can create" do
+      accounts = user.accounts.map{|a| a.id}
+      post :create, account: {access_token: 'test_wells', account_ids: accounts,
+        name:'Wells Fargo', type: 'wells', owner_id: "1", owner_type: "User"}
+      expect(response).to be_success
+      expect(assigns(:accounts).size).to eq 4
+    end
+    
+    it "can destroy" do
+      delete :destroy, id: account.id
+      expect(response).to be_success
+    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

data/spec/controllers/plaid_rails/application_controller_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Plaid
+  describe PlaidRails::ApplicationController do
+
+  end
+end

data/spec/controllers/plaid_rails/link_controller_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module PlaidRails
+  describe LinkController do
+    routes { PlaidRails::Engine.routes }
+   
+    it "authenticate with public token" do
+      xhr :post, :authenticate, public_token: 'test,wells,connected', name:'Wells Fargo', type: 'wells',
+        owner_id: "1", owner_type: "User"
+      expect(response).to be_success
+      expect(response).to render_template('plaid_rails/link/authenticate')
+    end
+    
+    it "can't authenticat with bad public token" do
+      xhr :post, :authenticate, public_token: 'badtoken', name:'Wells Fargo', type: 'wells',
+        owner_id: "1", owner_type: "User"
+      expect(response).to_not be_success
+      expect(response.status).to eq 500
+      expect(response.body).to eq "unauthorized product"
+    end
+    
+    it {
+      should permit(:public_token, :type,:name,:owner_id,:owner_type).
+        for(:authenticate, verb: :post, format: :js)}
+
+  end
+end