Feature/simplefin integration

Gemfile

@@ -69,6 +69,7 @@ gem "csv"
 gem "redcarpet"
 gem "stripe"
 gem "plaid"
+gem "httparty"
 gem "rotp", "~> 6.3"
 gem "rqrcode", "~> 3.0"
 gem "activerecord-import"

Gemfile.lock

@@ -239,6 +239,10 @@ GEM
       turbo-rails (>= 1.2)
     htmlbeautifier (1.4.3)
     htmlentities (4.3.4)
+    httparty (0.23.1)
+      csv
+      mini_mime (>= 1.0.0)
+      multi_xml (>= 0.5.2)
     i18n (1.14.7)
       concurrent-ruby (~> 1.0)
     i18n-tasks (1.0.15)
@@ -335,6 +339,8 @@ GEM
     mocha (2.7.1)
       ruby2_keywords (>= 0.0.5)
     msgpack (1.8.0)
+    multi_xml (0.7.2)
+      bigdecimal (~> 3.1)
     multipart-post (2.4.1)
     mutex_m (0.3.0)
     net-http (0.6.0)
@@ -648,6 +654,7 @@ DEPENDENCIES
   foreman
   hotwire-livereload
   hotwire_combobox
+  httparty
   i18n-tasks
   image_processing (>= 1.2)
   importmap-rails

app/controllers/accounts_controller.rb

@@ -5,6 +5,7 @@ class AccountsController < ApplicationController
   def index
     @manual_accounts = family.accounts.manual.alphabetically
     @plaid_items = family.plaid_items.ordered
+    @simplefin_items = family.simplefin_items.ordered
 
     render layout: "settings"
   end

app/controllers/properties_controller.rb

@@ -89,7 +89,7 @@ def address_params
 
     def property_params
       params.require(:account)
-            .permit(:name, :subtype, :accountable_type, accountable_attributes: [ :id, :year_built, :area_unit, :area_value ])
+            .permit(:name, :accountable_type, accountable_attributes: [ :id, :subtype, :year_built, :area_unit, :area_value ])
     end
 
     def set_property

app/controllers/simplefin_items_controller.rb

@@ -0,0 +1,139 @@
+class SimplefinItemsController < ApplicationController
+  before_action :set_simplefin_item, only: [ :show, :destroy, :sync, :setup_accounts, :complete_account_setup ]
+
+  def index
+    @simplefin_items = Current.family.simplefin_items.active.ordered
+    render layout: "settings"
+  end
+
+  def show
+  end
+
+  def new
+    @simplefin_item = Current.family.simplefin_items.build
+  end
+
+  def create
+    setup_token = simplefin_params[:setup_token]
+
+    return render_error("Please enter a SimpleFin setup token.") if setup_token.blank?
+
+    begin
+      @simplefin_item = Current.family.create_simplefin_item!(
+        setup_token: setup_token,
+        item_name: "SimpleFin Connection"
+      )
+
+      redirect_to simplefin_items_path, notice: "SimpleFin connection added successfully! Your accounts will appear shortly as they sync in the background."
+    rescue ArgumentError, URI::InvalidURIError
+      render_error("Invalid setup token. Please check that you copied the complete token from SimpleFin Bridge.", setup_token)
+    rescue Provider::Simplefin::SimplefinError => e
+      error_message = case e.error_type
+      when :token_compromised
+        "The setup token may be compromised, expired, or already used. Please create a new one."
+      else
+        "Failed to connect: #{e.message}"
+      end
+      render_error(error_message, setup_token)
+    rescue => e
+      Rails.logger.error("SimpleFin connection error: #{e.message}")
+      render_error("An unexpected error occurred. Please try again or contact support.", setup_token)
+    end
+  end
+
+  def destroy
+    @simplefin_item.destroy_later
+    redirect_to simplefin_items_path, notice: "SimpleFin connection will be removed"
+  end
+
+  def sync
+    @simplefin_item.sync_later
+    redirect_to simplefin_item_path(@simplefin_item), notice: "Sync started"
+  end
+
+  def setup_accounts
+    @simplefin_accounts = @simplefin_item.simplefin_accounts.includes(:account).where(accounts: { id: nil })
+    @account_type_options = [
+      [ "Checking or Savings Account", "Depository" ],
+      [ "Credit Card", "CreditCard" ],
+      [ "Investment Account", "Investment" ],
+      [ "Loan or Mortgage", "Loan" ],
+      [ "Other Asset", "OtherAsset" ],
+      [ "Skip - don't add", "Skip" ]
+    ]
+
+    # Subtype options for each account type
+    @subtype_options = {
+      "Depository" => {
+        label: "Account Subtype:",
+        options: Depository::SUBTYPES.map { |k, v| [ v[:long], k ] }
+      },
+      "CreditCard" => {
+        label: "",
+        options: [],
+        message: "Credit cards will be automatically set up as credit card accounts."
+      },
+      "Investment" => {
+        label: "Investment Type:",
+        options: Investment::SUBTYPES.map { |k, v| [ v[:long], k ] }
+      },
+      "Loan" => {
+        label: "Loan Type:",
+        options: Loan::SUBTYPES.map { |k, v| [ v[:long], k ] }
+      },
+      "OtherAsset" => {
+        label: nil,
+        options: [],
+        message: "No additional options needed for Other Assets."
+      }
+    }
+  end
+
+  def complete_account_setup
+    account_types = params[:account_types] || {}
+    account_subtypes = params[:account_subtypes] || {}
+
+    account_types.each do |simplefin_account_id, selected_type|
+      # Skip accounts that the user chose not to add
+      next if selected_type == "Skip"
+
+      simplefin_account = @simplefin_item.simplefin_accounts.find(simplefin_account_id)
+      selected_subtype = account_subtypes[simplefin_account_id]
+
+      # Default subtype for CreditCard since it only has one option
+      selected_subtype = "credit_card" if selected_type == "CreditCard" && selected_subtype.blank?
+
+      # Create account with user-selected type and subtype
+      account = Account.create_from_simplefin_account(
+        simplefin_account,
+        selected_type,
+        selected_subtype
+      )
+      simplefin_account.update!(account: account)
+    end
+
+    # Clear pending status and mark as complete
+    @simplefin_item.update!(pending_account_setup: false)
+
+    # Schedule account syncs for the newly created accounts
+    @simplefin_item.schedule_account_syncs
+
+    redirect_to simplefin_items_path, notice: "SimpleFin accounts have been set up successfully!"
+  end
+
+  private
+
+    def set_simplefin_item
+      @simplefin_item = Current.family.simplefin_items.find(params[:id])
+    end
+
+    def simplefin_params
+      params.require(:simplefin_item).permit(:setup_token)
+    end
+
+    def render_error(message, setup_token = nil)
+      @simplefin_item = Current.family.simplefin_items.build(setup_token: setup_token)
+      @error_message = message
+      render :new, status: :unprocessable_entity
+    end
+end

app/helpers/accounts_helper.rb

@@ -3,4 +3,14 @@ def summary_card(title:, &block)
     content = capture(&block)
     render "accounts/summary_card", title: title, content: content
   end
+
+  def sync_path_for(account)
+    if account.plaid_account_id.present?
+      sync_plaid_item_path(account.plaid_account.plaid_item)
+    elsif account.simplefin_account_id.present?
+      sync_simplefin_item_path(account.simplefin_account.simplefin_item)
+    else
+      sync_account_path(account)
+    end
+  end
 end

app/javascript/controllers/account_type_selector_controller.js

@@ -0,0 +1,45 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["subtypeContainer"]
+  static values = { accountId: String }
+
+  connect() {
+    // Show initial subtype dropdown based on current selection
+    this.updateSubtype()
+  }
+
+  updateSubtype(event) {
+    const selectElement = this.element.querySelector('select[name^="account_types"]')
+    const selectedType = selectElement ? selectElement.value : ''
+    const container = this.subtypeContainerTarget
+    const accountId = this.accountIdValue
+
+    // Hide all subtype selects
+    const subtypeSelects = container.querySelectorAll('.subtype-select')
+    subtypeSelects.forEach(select => {
+      select.style.display = 'none'
+      // Clear the name attribute so it doesn't get submitted
+      const selectElement = select.querySelector('select')
+      if (selectElement) {
+        selectElement.removeAttribute('name')
+      }
+    })
+
+   // Don't show any subtype select for Skip option
+   if (selectedType === 'Skip') {
+    return
+  }
+
+    // Show the relevant subtype select
+    const relevantSubtype = container.querySelector(`[data-type="${selectedType}"]`)
+    if (relevantSubtype) {
+      relevantSubtype.style.display = 'block'
+      // Re-add the name attribute so it gets submitted
+      const selectElement = relevantSubtype.querySelector('select')
+      if (selectElement) {
+        selectElement.setAttribute('name', `account_subtypes[${accountId}]`)
+      }
+    }
+  }
+}

app/models/account.rb

@@ -5,6 +5,7 @@ class Account < ApplicationRecord
 
   belongs_to :family
   belongs_to :import, optional: true
+  belongs_to :simplefin_account, optional: true
 
   has_many :import_mappings, as: :mappable, dependent: :destroy, class_name: "Import::Mapping"
   has_many :entries, dependent: :destroy
@@ -22,11 +23,12 @@ class Account < ApplicationRecord
   scope :assets, -> { where(classification: "asset") }
   scope :liabilities, -> { where(classification: "liability") }
   scope :alphabetically, -> { order(:name) }
-  scope :manual, -> { where(plaid_account_id: nil) }
+  scope :manual, -> { where(plaid_account_id: nil, simplefin_account_id: nil) }
 
   has_one_attached :logo
 
   delegated_type :accountable, types: Accountable::TYPES, dependent: :destroy
+  delegate :subtype, to: :accountable, allow_nil: true
 
   accepts_nested_attributes_for :accountable, update_only: true
 
@@ -71,6 +73,53 @@ def create_and_sync(attributes)
       account.sync_later
       account
     end
+
+
+    def create_from_simplefin_account(simplefin_account, account_type, subtype = nil)
+      # Get the balance from SimpleFin
+      balance = simplefin_account.current_balance || simplefin_account.available_balance || 0
+
+      # SimpleFin returns negative balances for credit cards (liabilities)
+      # But Maybe expects positive balances for liabilities
+      if account_type == "CreditCard" || account_type == "Loan"
+        balance = balance.abs
+      end
+
+      attributes = {
+        family: simplefin_account.simplefin_item.family,
+        name: simplefin_account.name,
+        balance: balance,
+        currency: simplefin_account.currency,
+        accountable_type: account_type,
+        accountable_attributes: build_simplefin_accountable_attributes(simplefin_account, account_type, subtype),
+        simplefin_account_id: simplefin_account.id
+      }
+
+      create_and_sync(attributes)
+    end
+
+
+    private
+
+      def build_simplefin_accountable_attributes(simplefin_account, account_type, subtype)
+        attributes = {}
+        attributes[:subtype] = subtype if subtype.present?
+
+        # Set account-type-specific attributes from SimpleFin data
+        case account_type
+        when "CreditCard"
+          # For credit cards, available_balance often represents available credit
+          if simplefin_account.available_balance.present? && simplefin_account.available_balance > 0
+            attributes[:available_credit] = simplefin_account.available_balance
+          end
+        when "Loan"
+          # For loans, we might get additional data from the raw_payload
+          # This is where loan-specific information could be extracted if available
+          # Currently we don't have specific loan fields from SimpleFin protocol
+        end
+
+        attributes
+      end
   end
 
   def institution_domain

app/models/account/linkable.rb

@@ -3,11 +3,12 @@ module Account::Linkable
 
   included do
     belongs_to :plaid_account, optional: true
+    belongs_to :simplefin_account, optional: true
   end
 
-  # A "linked" account gets transaction and balance data from a third party like Plaid
+  # A "linked" account gets transaction and balance data from a third party like Plaid or SimpleFin
   def linked?
-    plaid_account_id.present?
+    plaid_account_id.present? || simplefin_account_id.present?
   end
 
   # An "offline" or "unlinked" account is one where the user tracks values and

app/models/family.rb

@@ -1,5 +1,5 @@
 class Family < ApplicationRecord
-  include PlaidConnectable, Syncable, AutoTransferMatchable, Subscribeable
+  include PlaidConnectable, SimplefinConnectable, Syncable, AutoTransferMatchable, Subscribeable
 
   DATE_FORMATS = [
     [ "MM-DD-YYYY", "%m-%d-%Y" ],

app/models/family/simplefin_connectable.rb

@@ -0,0 +1,25 @@
+module Family::SimplefinConnectable
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :simplefin_items, dependent: :destroy
+  end
+
+  def can_connect_simplefin?
+    true # SimpleFin doesn't have regional restrictions like Plaid
+  end
+
+  def create_simplefin_item!(setup_token:, item_name: nil)
+    simplefin_provider = Provider::Simplefin.new
+    access_url = simplefin_provider.claim_access_url(setup_token)
+
+    simplefin_item = simplefin_items.create!(
+      name: item_name || "SimpleFin Connection",
+      access_url: access_url
+    )
+
+    simplefin_item.sync_later
+
+    simplefin_item
+  end
+end