DEV Community: Duarte Martins

Adding Plaid to Your Rails Application

Duarte Martins — Sun, 19 May 2024 19:31:38 +0000

This is a repost of the orignal article at: https://popadex.com/2024/05/19/adding-plaid-to-rails-app

Integrating Plaid into your Rails application allows you to link bank accounts and retrieve financial data, providing a seamless way to access and manage financial information. This guide will walk you through the process of adding Plaid to your Rails app, assuming you have TailwindCSS already set up for styling. We will cover the necessary steps to configure the backend, set up routes, and create views for linking bank accounts and displaying account details.

Step 1: Add the Plaid Gem

First, you need to add the Plaid gem to your Gemfile. This gem provides the necessary methods to interact with the Plaid API.

Gemfile:

gem 'plaid'

Then, run:

bundle install

Step 2: Set Up Plaid Configuration

Next, you need to initialize Plaid in your application. Add the following code to your initializers:

config/initializers/plaid.rb:

# Initialize Plaid configuration
plaid_config = Plaid::Configuration.new
plaid_config.server_index = Plaid::Configuration::Environment["sandbox"]  # or another environment as needed
plaid_config.api_key["PLAID-CLIENT-ID"] = Rails.application.credentials.dig(:development, :plaid, :client_id)
plaid_config.api_key["PLAID-SECRET"] = Rails.application.credentials.dig(:development, :plaid, :secret)

# Create an API client instance
api_client = Plaid::ApiClient.new(plaid_config)

# Create a Plaid API instance to use across the application
PlaidClient = Plaid::PlaidApi.new(api_client)

api_client.create_connection do |builder|
  builder.use Faraday::Response::Logger
end

Step 3: Set Up Routes

Add the necessary routes to your config/routes.rb file:

Rails.application.routes.draw do
  root 'plaid#index'
  post 'plaid/create_link_token', to: 'plaid#create_link_token'
  post 'plaid/exchange_public_token', to: 'plaid#exchange_public_token'
  get 'plaid/accounts', to: 'plaid#accounts'
end

Step 4: Create the Plaid Controller

Create a controller to handle Plaid operations:

app/controllers/plaid_controller.rb:

class PlaidController < ApplicationController
  before_action :authenticate_user!
  protect_from_forgery with: :null_session # to handle CSRF protection for API requests

  def index
  end

  def create_link_token
    user = current_user
    link_token_create_request = Plaid::LinkTokenCreateRequest.new({
      user: { client_user_id: user.id.to_s },
      client_name: 'Your App Name',
      products: %w[auth transactions],
      country_codes: ['US'],
      language: 'en'
    })

    begin
      link_token_response = PlaidClient.link_token_create(link_token_create_request)
      render json: { link_token: link_token_response.link_token }
    rescue Plaid::ApiError => e
      Rails.logger.error("Plaid API error: #{e.response_body}")
      render json: { error: e.response_body }, status: :internal_server_error
    end
  end

  def exchange_public_token
    Rails.logger.debug("Received public_token: #{params[:public_token]}")

    if params[:public_token].blank?
      Rails.logger.error('No public_token received')
      return render json: { error: 'No public_token received' }, status: :bad_request
    end

    begin
      exchange_token(params[:public_token])
      render json: { message: 'Bank account linked successfully.' }, status: :ok
    rescue Plaid::ApiError => e
      Rails.logger.error("Plaid API error: #{e.response_body}")
      render json: { error: e.response_body }, status: :internal_server_error
    end
  end

  def exchange_token(public_token)
    request = Plaid::ItemPublicTokenExchangeRequest.new({ public_token: public_token })

    response = PlaidClient.item_public_token_exchange(request)
    access_token = response.access_token
    item_id = response.item_id

    Rails.logger.debug("Access token: #{access_token}")
    Rails.logger.debug("Item ID: #{item_id}")

    if current_user.update(plaid_access_token: access_token, plaid_item_id: item_id)
      Rails.logger.debug('Access token and item ID saved successfully.')
      Rails.logger.debug("Current user after save: #{current_user.inspect}")
    else
      Rails.logger.error("Failed to save access token and item ID. Errors: #{current_user.errors.full_messages.join(', ')}")
    end
  end

  def accounts
    access_token = current_user.plaid_access_token

    if access_token.blank?
      flash[:error] = 'Access token is missing. Please link your account again.'
      return redirect_to root_path
    end

    begin
      accounts_request = Plaid::AccountsGetRequest.new({ access_token: access_token })
      accounts_response = PlaidClient.accounts_get(accounts_request)
      @accounts = accounts_response.accounts
    rescue Plaid::ApiError => e
      Rails.logger.error("Plaid API error: #{e.response_body}")
      flash[:error] = "Plaid API error: #{e.response_body}"
      return redirect_to root_path
    rescue StandardError => e
      Rails.logger.error("Internal server error: #{e.message}")
      flash[:error] = 'Internal server error'
      return redirect_to root_path
    end
  end
end

Step 5: Create the View

Create a view to display the link button and account details.

app/views/plaid/index.html.erb:

<!DOCTYPE html>
<html class="dark">
<head>
  <title>Account Details</title>
</head>
<body class="bg-white dark:bg-gray-900 text-black dark:text-white">
  <div class="container mx-auto p-4">
    <h1 class="text-3xl font-bold mb-4">Link Your Bank Account</h1>
    <button id="link-button" class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded dark:bg-gray-900 dark:hover:bg-gray-700 dark:text-white">Link Account</button>
    <script src="https://cdn.plaid.com/link/v2/stable/link-initialize.js"></script>
    <script>
      document.getElementById('link-button').onclick = function() {
        var csrfToken = document.querySelector('meta[name="csrf-token"]').getAttribute('content');

        fetch('/plaid/create_link_token', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'X-CSRF-Token': csrfToken
          },
          body: JSON.stringify({})
        })
        .then(response => response.json())
        .then(data => {
          if (data.error) {
            console.error('Error:', data.error);
            return;
          }

          var linkHandler = Plaid.create({
            token: data.link_token,
            onSuccess: function(public_token, metadata) {
              fetch('/plaid/exchange_public_token', {
                method: 'POST',
                headers: {
                  'Content-Type': 'application/json',
                  'X-CSRF-Token': csrfToken
                },
                body: JSON.stringify({ public_token: public_token })
              })
              .then(response => response.json())
              .then(data => {
                if (data.error) {
                  console.error('Error:', data.error);
                  return;
                }
                window.location.href = '/plaid/accounts';
              });
            },
            onExit: function(err, metadata) {
              console.log('Plaid link exit', err, metadata);
            }
          });

          linkHandler.open();
        })
        .catch(error => {
          console.error('Fetch error:', error);
        });
      };
    </script>
  </div>
</body>
</html>

app/views/plaid/accounts.html.erb:

<!DOCTYPE html>
<html class="dark">
<head>
  <title>Account Details</title>
</head>
<body class="bg-white dark:bg-gray-900 text-black dark:text-white">

  <div class="container mx-auto p-4">
    <h1 class="text-3xl font-bold mb-4">Account Details</h1>
    <% if @error %>
      <div class="bg-red-500 text-white p-2 rounded mb-4">
        Error: <%= @error %>
      </div>
    <% else %>
      <div class="overflow-x-auto">
        <table class="min-w-full bg-white dark:bg-gray-800 border border-gray-300 dark:border-gray-700">
          <thead>
            <tr class="bg-gray-200 dark:bg-gray-700">
              <th class="py-2 px-4 border-b border-gray-300 dark:border-gray-600">Name</th>
              <th class="py-2 px-4 border-b border-gray-300 dark:border-gray-600">Type</th>
              <th class="py-2 px-4 border-b border-gray-300 dark:border-gray-600">Subtype</th>
              <th class="py-2 px-4 border-b border-gray-300 dark:border-gray-600">Mask</th>
              <th class="py-2 px-4 border-b border-gray-300 dark:border-gray-600">Balance</th>
            </tr>
          </thead>
          <tbody>
            <% @accounts.each do |account| %>
              <tr class="border-b border-gray-300 dark:border-gray-700">
                <td class="py-2 px-4"><%= account.name %></td>
                <td class="py-2 px-4"><%= account.type %></td>
                <td class="py-2 px-4"><%= account.subtype %></td>
                <td class="py-2 px-4"><%= account.mask %></td>
                <td class="py-2 px-4"><%= number_to_currency(account.balances.available) %></td>
              </tr>
            <% end %>
          </tbody>
        </table>
      </div>
    <% end %>
  </div>
</body>
</html>

Conclusion

By following these steps, you can integrate Plaid into your Rails application to link bank accounts and display account details. This guide covers the necessary configuration, routes, controller actions, and views to set up Plaid. Make sure to handle API keys securely and configure the environment properly for production.

How Rails Powers PopaDex for Simplified Net Worth Tracking

Duarte Martins — Sat, 30 Mar 2024 23:56:50 +0000

The current landscape of personal finance management is full of bloated apps, half of which have a business model based on selling user data. PopaDex is a net worth tracking app that instead focuses on simplicity and ease of use to let users plan their finances. This article is about how Ruby on Rails, known for its 'convention over configuration' philosophy, has enabled PopaDex to rapidly develop a user-friendly platform that enables financial planning for its users. PopaDex uses some of Rails' latest features like solid_queue, and deployment tools like Kamal, to enhance user experience and maintain a robust, scalable service, all while getting to market quickly.

SolidQueue for Efficient Background Processing

One of the key challenges in any applications is managing long-running tasks without affecting the user experience. PopaDex leverages the solid_queue gem to handle background processing efficiently. This "DB-based queuing backend for Active Job" allows for tasks such as report generation and notifications to be processed in the background, ensuring the application remains responsive. The beauty of solid_queue lies in its simplicity and efficiency, obviating the need for more complex solutions like Redis or Sidekiq for background job management. This choice offers several distinct advantages:

Reduced Complexity: This simplicity is invaluable, especially for smaller teams (or a team of 1 in this case) and projects where resources are limited. By keeping the technology stack simple and manageable, more time and resources to can be dedicated to enhancing the core features of the app, rather than getting bogged down by complex infrastructure management.
Lower Surface Area: Without the need to integrate and maintain additional infrastructure like Redis or Sidekiq, PopaDex benefits from a leaner stack. This not only simplifies deployment but also reduces potential points of failure, making the app more robust.

Kamal for Effortless Deployment

Navigating the deployment landscape can be a daunting task for any developer, particularly those going it alone. PopaDex uses Kamal as its deployment solution, due to its straightforward and efficient nature. This tool is designed to facilitate the quick deployment of Rails applications across diverse environments, streamlining what can often be a complicated process. Kamal's appeal lies in its ability to demystify deployment, removing the hurdles commonly associated with Docker and app deployment in general. A couple of the main benefits of Kamal:

Simplified Deployment Process: Kamal's user-friendly approach means that even developers working solo can confidently deploy their applications without the need for extensive DevOps knowledge.
The robustness of being able to deploy swiftly to various Virtual Private Servers is also a great feature. PopaDex can maintain a high level of service availability and performance, as it allows for rapid scaling and redundancy across different hosting environments.

Omakase and CoPilot

The "omakase" approach of Rails works exceptionally well with tools like GitHub Copilot. Copilot thrives on context and convention, making Rails' standardised environment an ideal setting. Given Rails' convention over configuration ethos, Copilot can more accurately predict and offer suggestions that align with the Rails way of doing things, therefore accelerating development time even further. For example, when working within a Rails application, Copilot can quite accurately suggest controller actions or model validations, streamlining the development process.

Moreover, the "omakase" nature of Rails means that most of the gems and tools recommended by the Rails community are widely adopted and well-documented. This widespread adoption provides a rich dataset for GitHub Copilot to draw from, meaning that its suggestions are accurate and adhere to community best practices, more often than not. Naturally, this means solo developers can write more efficient, secure, and clean code for a huge variety of applications.

The Rails Architecture: An Ideal Tool for Solo Developers

Rails is a solo entrepreneur's best friend. Seriously, its monolithic and cohesive nature makes it a dream for anyone trying to hit the market fast and without a VC-funded engineering team. Using gems like solid_queue for those behind-the-scenes tasks and Kamal for fast and efficient deployment means that PopaDex keeps things running smooth and allows us to focus on adding value to our users. It's (famously) like having a Swiss Army knife; Rails equips developers with a curated set of features that streamline the development process, making it possible to achieve more with less.

Finally, Rails is only getting better. With Rails 8 on the horizon, progressive web apps will be first-class citizens and a whole host of other juicy features are setting the stage for an even more mature framework. Rails is going to reinforce its position as a mature and forward-thinking framework, and it has made all the difference in taking PopaDex to market.

How to delete your Facebook account in 2021

Duarte Martins — Sat, 06 Mar 2021 18:49:38 +0000

Originally on: santiagomartins.com

There are several reasons to consider deleting Facebook. A couple good ones are user privacy and psychological impact. First, as a company it has been fairly hostile to user privacy concerns, even when controlling for the fact that as a major platform it attracts more scrutiny than the vast majority of other software companies. Second, as a platform it works a bit like a slot machine, in that it promotes addictive behaviours and keeps you from engaging in deep work.

A few things might keep you from wanting to fully leave, however if you're reading this in all likelihood you don't use Facebook to the same extent you once did, considering that their key market is now the less tech-native segment of the baby-boomer generation. Many people have found that they don't feel like they're missing out on anything of value after leaving the platform, and I include myself among those that have enjoyed adopting a more minimalist approach to their digital lives.

A relevant concept here is Dunbar's number - a suggested cognitive limit to the number of people with whom one can maintain stable social relationships - named after British anthropologist Robin Dunbar. That number is 150, however it's worth bearing in mind that is the upper limit. In reality, most of us never come close to maintaining 150 close relationships at any one time.

Should you want to go ahead with deleting your account, there are a few things worth considering. One of Facebook's main uses is as a reminder for your friends' birthdays, so we want to make sure we export its calendar. Another thing we might want to do is a bit of privacy-focused prevention: delete our posts, leave all groups, download and delete our photos, and unlike all of our liked pages. This is in case Facebook's ghost profiles turn out to be a real practice, and the evidence seems to suggest they are. Ghost profiles are accounts that Facebook creates, with information it contains on people that aren't signed up to the platform. Finally, we might want to let our contacts know that we're leaving the platform and ask them to not upload any photos or information about us, should privacy be a concern.

Download all photos
Download Facebook's calendar
Unfriend, unlike, and delete all photos
Announce departure

1: Download all photos

It's fairly easy to export all of the photos you uploaded by simply using using Facebook's download your information tool. It's less easy to download photos you've been tagged in. For this you'll have to use some external tools, and most likely have to make use of a little programming.

The first and most simple option is using one of these IFTT recipes:

If for whatever reason you want to use another alternative you can follow this tutorial. Essentially go to your photos page at facebook.com/me/photos and run this JS script in your browser console to get the "FBIDs" of your photos:

for (link of document.getElementsByTagName('a')) { 
    if (!link.href.includes("?fbid=")) continue; 
    console.log(new URL(link.href).searchParams.get("fbid")); 
    }

Then feed that list to this python script which downloads your photos.

I would recommend then hosting your photos on another cloud-hosting provider such as Apple Photos.

2: Download Facebook's calendar

You can use this Chrome extension for that, it's quite straightforward.

3: Unfriend, unlike, and delete all photos

There are quite a few command line interfaces that can help you with this:

Another strategy is to scramble the information before you delete your account, however this requires a fair bit more time and programming some custom scripts.

4: Announce departure

As a final step I suggest announcing to your network that you're leaving the platform, leaving alternative contact details and requesting that others don't upload photos of you.
The process should take a few days to complete on Facebook's end, at which point your data is supposedly deleted from their servers.

Now enjoy being away from the platform - try to select for high value activities to do in your free time, and notice how you'll focus more on your most meaningful and rewarding relationships.

How to organise your Twitter follows into lists

Duarte Martins — Fri, 05 Mar 2021 19:46:05 +0000

Originally on www.santiagomartins.com

Twitter is a double edged sword: on one hand it gives you access to bleeding edge discussion on the most varied topics, on the other it's a hate-fuelled attention slot machine where the signal to noise ratio often makes the whole experience a waste of time at best, and positively harmful at worst.

One of the big causes of this is Twitter's own algorithm. Its workings aren't public, but whatever they are, they determine what you see and consume. One way to get around both these problems is by organising your Twitter into topic lists. Lists show you tweets in chronological order so aren't as vulnerable to the negative aspects of algorithmic curation. The problem is, we often have far too many follows for it to be practical to do this manually, but this is where we can leverage Twitter's API.

The first thing we want to do is to extract all of our followed users so we can begin organising them into the lists we want to create. The best place to do this is a Google Sheet, because we can easily assign lists to each user, and then use the Google Sheets API in combination with Twitter's to get the list of users we want to organise and put them in their designated list.

To organise our followed users into lists we need to do the following:

Create a Twitter app
Create a Google app
Organise users into lists
Run the scripts to assign users to those lists.

Create a Twitter app

This can be done at https://developer.twitter.com/en/portal/dashboard. Make sure to keep the access credentials and set to read & write.

Create a Google app

Go to the Google developer console and create a new app. Activate the Google Sheets API and download the json file with your credentials.

Organise users into lists

This is where the fun starts. We want to create a spreadsheet with the following structure so that we can organise our followed users into lists:

ID	Name	Description
5367537	john bob	Economics professor at an Ivy League
942847	jazz	Being a footballer in the 80s took its toll
1235342790	granny	Building 12 philosophy startups. ex-@memeco

So the first thing we need to do is export this data from our twitter account into a csv file.


@client =
  Twitter::REST::Client.new do |config|
    config.consumer_key = 'your consumer key'
    config.consumer_secret = 'your consumer secret'
    config.access_token = 'your access token'
    config.bearer_token = 'your bearer token'
    config.access_token_secret = 'your access token secret'
  end

def export_users(user)
  File.open('List.csv', 'w+') do |file|
    @client
      .friend_ids(user)
      .each do |f|
        file <<
          "#{f}, #{@client.user(f).name}, #{@client.user(f).description.gsub("\n", ' ')}\n"
    rescue Twitter::Error::TooManyRequests => e
      # NOTE: Your process could go to sleep for up to 15 minutes but if you
      # retry any sooner, it will almost certainly fail with the same exception.
      puts 'retrying..'
      sleep e.rate_limit.reset_in + 1
      retry
      end
  end
end

export_users('my_username')

Then we want to upload that CSV to a Google Sheet and fill in the list name we want each user to belong to.

4. Once we've done that we can retreive that table and work with it.


# frozen_string_literal: true

require "google/apis/sheets_v4"
require "googleauth"
require "googleauth/stores/file_token_store"
require "fileutils"

OOB_URI = "urn:ietf:wg:oauth:2.0:oob"
APPLICATION_NAME = "Google Sheets API Ruby Quickstart"
CREDENTIALS_PATH = "lib/credentials.json"
# The file token.yaml stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
TOKEN_PATH = "token.yaml"
SCOPE = Google::Apis::SheetsV4::AUTH_SPREADSHEETS_READONLY

##
# Ensure valid credentials, either by restoring from the saved credentials
# files or intitiating an OAuth2 authorization. If authorization is required,
# the user's default browser will be launched to approve the request.
#
# @return [Google::Auth::UserRefreshCredentials] OAuth2 credentials
def authorize
  client_id = Google::Auth::ClientId.from_file CREDENTIALS_PATH
  token_store = Google::Auth::Stores::FileTokenStore.new file: TOKEN_PATH
  authorizer = Google::Auth::UserAuthorizer.new client_id, SCOPE, token_store
  user_id = "default"
  credentials = authorizer.get_credentials user_id
  if credentials.nil?
    url = authorizer.get_authorization_url base_url: OOB_URI
    puts "Open the following URL in the browser and enter the " \
         "resulting code after authorization:\n" + url
    code = gets
    credentials = authorizer.get_and_store_credentials_from_code(
      user_id: user_id, code: code, base_url: OOB_URI
    )
  end
  credentials
end

# Initialize the API
service = Google::Apis::SheetsV4::SheetsService.new
service.client_options.application_name = APPLICATION_NAME
service.authorization = authorize

# use your spreadsheet
spreadsheet_id = "id_goes_here"
range = "Sheet2!A:C"
response = service.get_spreadsheet_values spreadsheet_id, range
response_array = []

response.values.drop(1).each do |row|
  # Print columns A and C, which correspond to indices 0 and 2.
  unless row[2].nil?
    response_array << (row[0]).to_i
    response_array << (row[2]).to_s
  end
end

response_array.drop(0)

$hash = Hash[*response_array]

Finally, we can use the Twitter API to put each user in their designated list.



require "twitter"
require_relative "sheets"

@client =
  Twitter::REST::Client.new do |config|
    config.consumer_key = 'your consumer key'
    config.consumer_secret = 'your consumer secret'
    config.access_token = 'your access token'
    config.bearer_token = 'your bearer token'
    config.access_token_secret = 'your access token secret'
  end

all_lists = @client.lists
$hash.each do |user_id, list_name|
  user_id_name = @client.user(user_id).name

  if all_lists.any? { |list| list.name == list_name } # if list exists
    lists = all_lists.select { |list| list.name == list_name } # get lists with the hash list name
    lists.each do |list| # for each list
      if @client.list_members("duarteosrm", list.slug).any? { |member| member.name == user_id_name }
        puts "#{user_id_name} already in #{list.name} list"
      else # unless user exists in list
        @client.add_list_member("duarteosrm", list.slug, user_id) # add user
        puts "added #{user_id_name} to existing list, #{list.name}"
      end
    end
  else # else if list does not exist
    @client.create_list(list_name) # create list
    puts "list created: #{list_name}"
    lists = @client.lists.select { |list| list.name == list_name } # get lists with the hash list name
    lists.each do |list| # for each list
      @client.add_list_member("duarteosrm", list.slug, user_id) # add user
      puts "added #{user_id_name} to new list, #{list.name}"
    end
  end
rescue Twitter::Error::TooManyRequests => e
  # NOTE: Your process could go to sleep for up to 15 minutes but if you
  # retry any sooner, it will almost certainly fail with the same exception.
  puts "retrying.."
  sleep e.rate_limit.reset_in + 1
  retry
rescue Twitter::Error::NotFound
  puts "user not found"
  next
rescue Twitter::Error::Forbidden
  puts "cannot add to lists"
  next
end

Bonus: I wanted to unfollow all of the users I had put in lists that didn't follow me back, so I created the following script to do so:



require "twitter"
require_relative "sheets"

@client =
  Twitter::REST::Client.new do |config|
    config.consumer_key = 'your consumer key'
    config.consumer_secret = 'your consumer secret'
    config.access_token = 'your access token'
    config.bearer_token = 'your bearer token'
    config.access_token_secret = 'your access token secret'
  end

begin
  id = @client.user.id
  followers = @client.follower_ids(id)
rescue Twitter::Error::TooManyRequests => e
  # NOTE: Your process could go to sleep for up to 15 minutes but if you
  # retry any sooner, it will almost certainly fail with the same exception.
  puts "retrying.."
  sleep e.rate_limit.reset_in + 1
  retry
end

$hash.each do |user_id, list_name|
  @client.unfollow(user_id) unless followers.any? { |follower| follower == user_id }
  puts "unfollowed #{@client.user(user_id).name} unless they follow back"

rescue Twitter::Error::TooManyRequests => e
  # NOTE: Your process could go to sleep for up to 15 minutes but if you
  # retry any sooner, it will almost certainly fail with the same exception.
  puts "retrying.."
  sleep e.rate_limit.reset_in + 1
  retry
rescue Twitter::Error::NotFound
  puts "user not found"
  next
rescue Twitter::Error::Forbidden
  puts "cannot add to lists"
  next
end