diff --git a/app/components/UI/account/chart.rb b/app/components/UI/account/chart.rb new file mode 100644 index 00000000000..1e58529aa5b --- /dev/null +++ b/app/components/UI/account/chart.rb @@ -0,0 +1,72 @@ +class UI::Account::Chart < ApplicationComponent + attr_reader :account + + def initialize(account:, period: nil, view: nil) + @account = account + @period = period + @view = view + end + + def period + @period ||= Period.last_30_days + end + + def holdings_value_money + account.balance_money - account.cash_balance_money + end + + def view_balance_money + case view + when "balance" + account.balance_money + when "holdings_balance" + holdings_value_money + when "cash_balance" + account.cash_balance_money + end + end + + def title + case account.accountable_type + when "Investment", "Crypto" + case view + when "balance" + "Total account value" + when "holdings_balance" + "Holdings value" + when "cash_balance" + "Cash value" + end + when "Property", "Vehicle" + "Estimated #{account.accountable_type.humanize.downcase} value" + when "CreditCard", "OtherLiability" + "Debt balance" + when "Loan" + "Remaining principal balance" + else + "Balance" + end + end + + def foreign_currency? + account.currency != account.family.currency + end + + def converted_balance_money + return nil unless foreign_currency? + + account.balance_money.exchange_to(account.family.currency, fallback_rate: 1) + end + + def view + @view ||= "balance" + end + + def series + account.balance_series(period: period, view: view) + end + + def trend + series.trend + end +end diff --git a/app/components/UI/account_page.html.erb b/app/components/UI/account_page.html.erb new file mode 100644 index 00000000000..37d3bd41e42 --- /dev/null +++ b/app/components/UI/account_page.html.erb @@ -0,0 +1,29 @@ +<%= turbo_stream_from account %> + +<%= turbo_frame_tag id do %> + <%= tag.div class: "space-y-4 pb-32" do %> + <%= render "accounts/show/header", account: account, title: title, subtitle: subtitle %> + + <%= render UI::Account::Chart.new(account: account, period: chart_period, view: chart_view) %> + + + <% end %> +<% end %> diff --git a/app/components/UI/account_page.rb b/app/components/UI/account_page.rb new file mode 100644 index 00000000000..5d3dd54a259 --- /dev/null +++ b/app/components/UI/account_page.rb @@ -0,0 +1,59 @@ +class UI::AccountPage < ApplicationComponent + attr_reader :account, :chart_view, :chart_period + + renders_one :activity_feed, ->(feed_data:, pagy:, search:) { UI::Account::ActivityFeed.new(feed_data: feed_data, pagy: pagy, search: search) } + + def initialize(account:, chart_view: nil, chart_period: nil, active_tab: nil) + @account = account + @chart_view = chart_view + @chart_period = chart_period + @active_tab = active_tab + end + + def id + dom_id(account, :container) + end + + def broadcast_channel + account + end + + def broadcast_refresh! + Turbo::StreamsChannel.broadcast_replace_to(broadcast_channel, target: id, renderable: self, layout: false) + end + + def title + account.name + end + + def subtitle + return nil unless account.property? + + account.property.address + end + + def active_tab + tabs.find { |tab| tab == @active_tab&.to_sym } || tabs.first + end + + def tabs + case account.accountable_type + when "Investment" + [ :activity, :holdings ] + when "Property", "Vehicle", "Loan" + [ :activity, :overview ] + else + [ :activity ] + end + end + + def tab_content_for(tab) + case tab + when :activity + activity_feed + when :holdings, :overview + # Accountable is responsible for implementing the partial in the correct folder + render "#{account.accountable_type.downcase.pluralize}/tabs/#{tab}", account: account + end + end +end diff --git a/app/components/application_component.rb b/app/components/application_component.rb new file mode 100644 index 00000000000..37cb953da10 --- /dev/null +++ b/app/components/application_component.rb @@ -0,0 +1,4 @@ +class ApplicationComponent < ViewComponent::Base + # These don't work as expected with helpers.turbo_frame_tag, etc., so we include them here + include Turbo::FramesHelper, Turbo::StreamsHelper +end diff --git a/app/components/design_system_component.rb b/app/components/design_system_component.rb new file mode 100644 index 00000000000..35d21681dee --- /dev/null +++ b/app/components/design_system_component.rb @@ -0,0 +1,2 @@ +class DesignSystemComponent < ViewComponent::Base +end diff --git a/app/components/tabs_component.html.erb b/app/components/tabs_component.html.erb deleted file mode 100644 index bfceddad3cf..00000000000 --- a/app/components/tabs_component.html.erb +++ /dev/null @@ -1,18 +0,0 @@ -<%= tag.div data: { - controller: "tabs", - testid: testid, - tabs_session_key_value: session_key, - tabs_url_param_key_value: url_param_key, - tabs_nav_btn_active_class: active_btn_classes, - tabs_nav_btn_inactive_class: inactive_btn_classes -} do %> - <% if unstyled? %> - <%= content %> - <% else %> - <%= nav %> - - <% panels.each do |panel| %> - <%= panel %> - <% end %> - <% end %> -<% end %> diff --git a/app/controllers/accounts_controller.rb b/app/controllers/accounts_controller.rb index c1804637189..b78c54ad9ce 100644 --- a/app/controllers/accounts_controller.rb +++ b/app/controllers/accounts_controller.rb @@ -1,5 +1,5 @@ class AccountsController < ApplicationController - before_action :set_account, only: %i[sync chart sparkline toggle_active] + before_action :set_account, only: %i[sync sparkline toggle_active show destroy] include Periodable def index @@ -9,6 +9,22 @@ def index render layout: "settings" end + def sync_all + family.sync_later + redirect_to accounts_path, notice: "Syncing accounts..." + end + + def show + @chart_view = params[:chart_view] || "balance" + @tab = params[:tab] + @q = params.fetch(:q, {}).permit(:search) + entries = @account.entries.search(@q).reverse_chronological + + @pagy, @entries = pagy(entries, limit: params[:per_page] || "10") + + @activity_feed_data = Account::ActivityFeedData.new(@account, @entries) + end + def sync unless @account.syncing? @account.sync_later @@ -17,11 +33,6 @@ def sync redirect_to account_path(@account) end - def chart - @chart_view = params[:chart_view] || "balance" - render layout: "application" - end - def sparkline etag_key = @account.family.build_cache_key("#{@account.id}_sparkline", invalidate_on_data_updates: true) @@ -42,6 +53,15 @@ def toggle_active redirect_to accounts_path end + def destroy + if @account.linked? + redirect_to account_path(@account), alert: "Cannot delete a linked account" + else + @account.destroy_later + redirect_to accounts_path, notice: "Account scheduled for deletion" + end + end + private def family Current.family diff --git a/app/controllers/api/v1/base_controller.rb b/app/controllers/api/v1/base_controller.rb index a9b577d1850..f176fff4b68 100644 --- a/app/controllers/api/v1/base_controller.rb +++ b/app/controllers/api/v1/base_controller.rb @@ -98,7 +98,7 @@ def authenticate_api_key @current_user = @api_key.user @api_key.update_last_used! @authentication_method = :api_key - @rate_limiter = ApiRateLimiter.new(@api_key) + @rate_limiter = ApiRateLimiter.limit(@api_key) setup_current_context_for_api true end diff --git a/app/controllers/concerns/accountable_resource.rb b/app/controllers/concerns/accountable_resource.rb index 9daa0ae2f82..3b06ff1632d 100644 --- a/app/controllers/concerns/accountable_resource.rb +++ b/app/controllers/concerns/accountable_resource.rb @@ -2,9 +2,9 @@ module AccountableResource extend ActiveSupport::Concern included do - include ScrollFocusable, Periodable + include Periodable - before_action :set_account, only: [ :show, :edit, :update, :destroy ] + before_action :set_account, only: [ :show, :edit, :update ] before_action :set_link_options, only: :new end @@ -27,9 +27,7 @@ def show @q = params.fetch(:q, {}).permit(:search) entries = @account.entries.search(@q).reverse_chronological - set_focused_record(entries, params[:focused_record_id]) - - @pagy, @entries = pagy(entries, limit: params[:per_page] || "10", params: ->(params) { params.except(:focused_record_id) }) + @pagy, @entries = pagy(entries, limit: params[:per_page] || "10") end def edit @@ -45,12 +43,13 @@ def create def update # Handle balance update if provided if account_params[:balance].present? - result = @account.update_balance(balance: account_params[:balance], currency: account_params[:currency]) + result = @account.set_current_balance(account_params[:balance].to_d) unless result.success? @error_message = result.error_message render :edit, status: :unprocessable_entity return end + @account.sync_later end # Update remaining account attributes @@ -62,16 +61,7 @@ def update end @account.lock_saved_attributes! - redirect_back_or_to @account, notice: t("accounts.update.success", type: accountable_type.name.underscore.humanize) - end - - def destroy - if @account.linked? - redirect_to account_path(@account), alert: "Cannot delete a linked account" - else - @account.destroy_later - redirect_to accounts_path, notice: t("accounts.destroy.success", type: accountable_type.name.underscore.humanize) - end + redirect_back_or_to account_path(@account), notice: t("accounts.update.success", type: accountable_type.name.underscore.humanize) end private diff --git a/app/controllers/concerns/scroll_focusable.rb b/app/controllers/concerns/scroll_focusable.rb deleted file mode 100644 index 7eb47a1b39f..00000000000 --- a/app/controllers/concerns/scroll_focusable.rb +++ /dev/null @@ -1,21 +0,0 @@ -module ScrollFocusable - extend ActiveSupport::Concern - - def set_focused_record(record_scope, record_id, default_per_page: 10) - return unless record_id.present? - - @focused_record = record_scope.find_by(id: record_id) - - record_index = record_scope.pluck(:id).index(record_id) - - return unless record_index - - page_of_focused_record = (record_index / (params[:per_page]&.to_i || default_per_page)) + 1 - - if params[:page]&.to_i != page_of_focused_record - ( - redirect_to(url_for(page: page_of_focused_record, focused_record_id: record_id)) - ) - end - end -end diff --git a/app/controllers/family_exports_controller.rb b/app/controllers/family_exports_controller.rb new file mode 100644 index 00000000000..992d68b3dc9 --- /dev/null +++ b/app/controllers/family_exports_controller.rb @@ -0,0 +1,47 @@ +class FamilyExportsController < ApplicationController + include StreamExtensions + + before_action :require_admin + before_action :set_export, only: [ :download ] + + def new + # Modal view for initiating export + end + + def create + @export = Current.family.family_exports.create! + FamilyDataExportJob.perform_later(@export) + + respond_to do |format| + format.html { redirect_to settings_profile_path, notice: "Export started. You'll be able to download it shortly." } + format.turbo_stream { + stream_redirect_to settings_profile_path, notice: "Export started. You'll be able to download it shortly." + } + end + end + + def index + @exports = Current.family.family_exports.ordered.limit(10) + render layout: false # For turbo frame + end + + def download + if @export.downloadable? + redirect_to @export.export_file, allow_other_host: true + else + redirect_to settings_profile_path, alert: "Export not ready for download" + end + end + + private + + def set_export + @export = Current.family.family_exports.find(params[:id]) + end + + def require_admin + unless Current.user.admin? + redirect_to root_path, alert: "Access denied" + end + end +end diff --git a/app/controllers/properties_controller.rb b/app/controllers/properties_controller.rb index 8b2ec062ce3..7a1db5de3eb 100644 --- a/app/controllers/properties_controller.rb +++ b/app/controllers/properties_controller.rb @@ -37,10 +37,10 @@ def balances end def update_balances - result = @account.update_balance(balance: balance_params[:balance], currency: balance_params[:currency]) + result = @account.set_current_balance(balance_params[:balance].to_d) if result.success? - @success_message = result.updated? ? "Balance updated successfully." : "No changes made. Account is already up to date." + @success_message = "Balance updated successfully." if @account.active? render :balances diff --git a/app/controllers/transactions_controller.rb b/app/controllers/transactions_controller.rb index 1c260d8feea..707fa5d4f94 100644 --- a/app/controllers/transactions_controller.rb +++ b/app/controllers/transactions_controller.rb @@ -1,5 +1,5 @@ class TransactionsController < ApplicationController - include ScrollFocusable, EntryableResource + include EntryableResource before_action :store_params!, only: :index @@ -21,12 +21,7 @@ def index :transfer_as_inflow, :transfer_as_outflow ) - @pagy, @transactions = pagy(base_scope, limit: per_page, params: ->(p) { p.except(:focused_record_id) }) - - # No performance penalty by default. Only runs queries if the record is set. - if params[:focused_record_id].present? - set_focused_record(base_scope, params[:focused_record_id], default_per_page: per_page) - end + @pagy, @transactions = pagy(base_scope, limit: per_page) end def clear_filter @@ -115,7 +110,7 @@ def update private def per_page - params[:per_page].to_i.positive? ? params[:per_page].to_i : 50 + params[:per_page].to_i.positive? ? params[:per_page].to_i : 20 end def needs_rule_notification?(transaction) @@ -159,10 +154,6 @@ def search_params cleaned_params.delete(:amount_operator) unless cleaned_params[:amount].present? - # Only add default start_date if params are blank AND filters weren't explicitly cleared - if cleaned_params.blank? && params[:filter_cleared].blank? - cleaned_params[:start_date] = 30.days.ago.to_date - end cleaned_params end diff --git a/app/controllers/valuations_controller.rb b/app/controllers/valuations_controller.rb index 90aa1da0c86..5234c0beaaa 100644 --- a/app/controllers/valuations_controller.rb +++ b/app/controllers/valuations_controller.rb @@ -1,22 +1,46 @@ class ValuationsController < ApplicationController include EntryableResource, StreamExtensions + def confirm_create + @account = Current.family.accounts.find(params.dig(:entry, :account_id)) + @entry = @account.entries.build(entry_params.merge(currency: @account.currency)) + + @reconciliation_dry_run = @entry.account.create_reconciliation( + balance: entry_params[:amount], + date: entry_params[:date], + dry_run: true + ) + + render :confirm_create + end + + def confirm_update + @entry = Current.family.entries.find(params[:id]) + @account = @entry.account + @entry.assign_attributes(entry_params.merge(currency: @account.currency)) + + @reconciliation_dry_run = @entry.account.update_reconciliation( + @entry, + balance: entry_params[:amount], + date: entry_params[:date], + dry_run: true + ) + + render :confirm_update + end + def create account = Current.family.accounts.find(params.dig(:entry, :account_id)) - result = account.update_balance( + result = account.create_reconciliation( balance: entry_params[:amount], date: entry_params[:date], - currency: entry_params[:currency], - notes: entry_params[:notes] ) if result.success? - @success_message = result.updated? ? "Balance updated" : "No changes made. Account is already up to date." - respond_to do |format| - format.html { redirect_back_or_to account_path(account), notice: @success_message } - format.turbo_stream { stream_redirect_back_or_to(account_path(account), notice: @success_message) } + format.html { redirect_back_or_to account_path(account), notice: "Account updated" } + format.turbo_stream { stream_redirect_back_or_to(account_path(account), notice: "Account updated") } end else @error_message = result.error_message @@ -25,18 +49,22 @@ def create end def update - result = @entry.account.update_balance( - date: @entry.date, - balance: entry_params[:amount], - currency: entry_params[:currency], - notes: entry_params[:notes] - ) + # Notes updating is independent of reconciliation, just a simple CRUD operation + @entry.update!(notes: entry_params[:notes]) if entry_params[:notes].present? - if result.success? + if entry_params[:date].present? && entry_params[:amount].present? + result = @entry.account.update_reconciliation( + @entry, + balance: entry_params[:amount], + date: entry_params[:date], + ) + end + + if result.nil? || result.success? @entry.reload respond_to do |format| - format.html { redirect_back_or_to account_path(@entry.account), notice: result.updated? ? "Balance updated" : "No changes made. Account is already up to date." } + format.html { redirect_back_or_to account_path(@entry.account), notice: "Entry updated" } format.turbo_stream do render turbo_stream: [ turbo_stream.replace( @@ -56,7 +84,6 @@ def update private def entry_params - params.require(:entry) - .permit(:date, :amount, :currency, :notes) + params.require(:entry).permit(:date, :amount, :notes) end end diff --git a/app/data_migrations/balance_component_migrator.rb b/app/data_migrations/balance_component_migrator.rb new file mode 100644 index 00000000000..806c2abc744 --- /dev/null +++ b/app/data_migrations/balance_component_migrator.rb @@ -0,0 +1,59 @@ +class BalanceComponentMigrator + def self.run + ActiveRecord::Base.transaction do + # Step 1: Update flows factor + ActiveRecord::Base.connection.execute <<~SQL + UPDATE balances SET + flows_factor = CASE WHEN a.classification = 'asset' THEN 1 ELSE -1 END + FROM accounts a + WHERE a.id = balances.account_id + SQL + + # Step 2: Set start values using LOCF (Last Observation Carried Forward) + ActiveRecord::Base.connection.execute <<~SQL + UPDATE balances b1 + SET + start_cash_balance = COALESCE(prev.cash_balance, 0), + start_non_cash_balance = COALESCE(prev.balance - prev.cash_balance, 0) + FROM balances b1_inner + LEFT JOIN LATERAL ( + SELECT + b2.cash_balance, + b2.balance + FROM balances b2 + WHERE b2.account_id = b1_inner.account_id + AND b2.currency = b1_inner.currency + AND b2.date < b1_inner.date + ORDER BY b2.date DESC + LIMIT 1 + ) prev ON true + WHERE b1.id = b1_inner.id + SQL + + # Step 3: Calculate net inflows + # A slight workaround to the fact that we can't easily derive inflows/outflows from our current data model, and + # the tradeoff not worth it since each new sync will fix it. So instead, we sum up *net* flows, and throw the signed + # amount in the "inflows" column, and zero-out the "outflows" column so our math works correctly with incomplete data. + ActiveRecord::Base.connection.execute <<~SQL + UPDATE balances SET + cash_inflows = (cash_balance - start_cash_balance) * flows_factor, + cash_outflows = 0, + non_cash_inflows = ((balance - cash_balance) - start_non_cash_balance) * flows_factor, + non_cash_outflows = 0, + net_market_flows = 0 + SQL + + # Verify data integrity + # All end_balance values should match the original balance + invalid_count = ActiveRecord::Base.connection.select_value(<<~SQL) + SELECT COUNT(*) + FROM balances b + WHERE ABS(b.balance - b.end_balance) > 0.0001 + SQL + + if invalid_count > 0 + raise "Data migration failed validation: #{invalid_count} balances have incorrect end_balance values" + end + end + end +end diff --git a/app/helpers/application_helper.rb b/app/helpers/application_helper.rb index 094cd8408c7..3ec81e824a9 100644 --- a/app/helpers/application_helper.rb +++ b/app/helpers/application_helper.rb @@ -21,7 +21,7 @@ def icon(key, size: "md", color: "default", custom: false, as_button: false, **o if custom inline_svg_tag("#{key}.svg", class: icon_classes, **opts) elsif as_button - render ButtonComponent.new(variant: "icon", class: extra_classes, icon: key, size: size, type: "button", **opts) + render DS::Button.new(variant: "icon", class: extra_classes, icon: key, size: size, type: "button", **opts) else lucide_icon(key, class: icon_classes, **opts) end diff --git a/app/helpers/styled_form_builder.rb b/app/helpers/styled_form_builder.rb index b614255dd63..f90888d726f 100644 --- a/app/helpers/styled_form_builder.rb +++ b/app/helpers/styled_form_builder.rb @@ -50,7 +50,7 @@ def toggle(method, options = {}, checked_value = "1", unchecked_value = "0") checked = object ? object.send(method) : options[:checked] @template.render( - ToggleComponent.new( + DS::Toggle.new( id: field_id, name: field_name, checked: checked, @@ -67,7 +67,7 @@ def submit(value = nil, options = {}) value ||= submit_default_value @template.render( - ButtonComponent.new( + DS::Button.new( text: value, data: (options[:data] || {}).merge({ turbo_submits_with: "Submitting..." }), full_width: true diff --git a/app/javascript/controllers/auto_submit_form_controller.js b/app/javascript/controllers/auto_submit_form_controller.js index 18744c4d359..cf4be4e8752 100644 --- a/app/javascript/controllers/auto_submit_form_controller.js +++ b/app/javascript/controllers/auto_submit_form_controller.js @@ -10,16 +10,14 @@ export default class extends Controller { connect() { this.autoTargets.forEach((element) => { - const event = - element.dataset.autosubmitTriggerEvent || this.triggerEventValue; + const event = this.#getTriggerEvent(element); element.addEventListener(event, this.handleInput); }); } disconnect() { this.autoTargets.forEach((element) => { - const event = - element.dataset.autosubmitTriggerEvent || this.triggerEventValue; + const event = this.#getTriggerEvent(element); element.removeEventListener(event, this.handleInput); }); } @@ -33,6 +31,50 @@ export default class extends Controller { }, this.#debounceTimeout(target)); }; + #getTriggerEvent(element) { + // Check if element has explicit trigger event set + if (element.dataset.autosubmitTriggerEvent) { + return element.dataset.autosubmitTriggerEvent; + } + + // Check if form has explicit trigger event set + if (this.triggerEventValue !== "input") { + return this.triggerEventValue; + } + + // Otherwise, choose trigger event based on element type + const type = element.type || element.tagName; + + switch (type.toLowerCase()) { + case "text": + case "email": + case "password": + case "search": + case "tel": + case "url": + case "textarea": + return "blur"; + case "number": + case "date": + case "datetime-local": + case "month": + case "time": + case "week": + case "color": + return "change"; + case "checkbox": + case "radio": + case "select": + case "select-one": + case "select-multiple": + return "change"; + case "range": + return "input"; + default: + return "blur"; + } + } + #debounceTimeout(element) { if (element.dataset.autosubmitDebounceTimeout) { return Number.parseInt(element.dataset.autosubmitDebounceTimeout); diff --git a/app/javascript/controllers/focus_record_controller.js b/app/javascript/controllers/focus_record_controller.js deleted file mode 100644 index 0cc3fc9a64a..00000000000 --- a/app/javascript/controllers/focus_record_controller.js +++ /dev/null @@ -1,21 +0,0 @@ -import { Controller } from "@hotwired/stimulus"; - -// Connects to data-controller="focus-record" -export default class extends Controller { - static values = { - id: String, - }; - - connect() { - const element = document.getElementById(this.idValue); - - if (element) { - element.scrollIntoView({ behavior: "smooth" }); - - // Remove the focused_record_id parameter from URL - const url = new URL(window.location); - url.searchParams.delete("focused_record_id"); - window.history.replaceState({}, "", url); - } - } -} diff --git a/app/jobs/family_data_export_job.rb b/app/jobs/family_data_export_job.rb new file mode 100644 index 00000000000..1b62bd66c0d --- /dev/null +++ b/app/jobs/family_data_export_job.rb @@ -0,0 +1,22 @@ +class FamilyDataExportJob < ApplicationJob + queue_as :default + + def perform(family_export) + family_export.update!(status: :processing) + + exporter = Family::DataExporter.new(family_export.family) + zip_file = exporter.generate_export + + family_export.export_file.attach( + io: zip_file, + filename: family_export.filename, + content_type: "application/zip" + ) + + family_export.update!(status: :completed) + rescue => e + Rails.logger.error "Family export failed: #{e.message}" + Rails.logger.error e.backtrace.join("\n") + family_export.update!(status: :failed) + end +end diff --git a/app/models/account.rb b/app/models/account.rb index 222062b41d2..6a21c3e341c 100644 --- a/app/models/account.rb +++ b/app/models/account.rb @@ -1,6 +1,5 @@ class Account < ApplicationRecord - include Syncable, Monetizable, Chartable, Linkable, Enrichable - include AASM + include AASM, Syncable, Monetizable, Chartable, Linkable, Enrichable, Anchorable, Reconcileable validates :name, :balance, :currency, presence: true @@ -59,26 +58,14 @@ class << self def create_and_sync(attributes) attributes[:accountable_attributes] ||= {} # Ensure accountable is created, even if empty account = new(attributes.merge(cash_balance: attributes[:balance])) - initial_balance = attributes.dig(:accountable_attributes, :initial_balance)&.to_d || 0 + initial_balance = attributes.dig(:accountable_attributes, :initial_balance)&.to_d transaction do - # Create 2 valuations for new accounts to establish a value history for users to see - account.entries.build( - name: Valuation.build_current_anchor_name(account.accountable_type), - date: Date.current, - amount: account.balance, - currency: account.currency, - entryable: Valuation.new - ) - account.entries.build( - name: Valuation.build_opening_anchor_name(account.accountable_type), - date: 1.day.ago.to_date, - amount: initial_balance, - currency: account.currency, - entryable: Valuation.new - ) - account.save! + + manager = Account::OpeningBalanceManager.new(account) + result = manager.set_opening_balance(balance: initial_balance || account.balance) + raise result.error if result.error end account.sync_later @@ -127,11 +114,6 @@ def current_holdings .order(amount: :desc) end - - def update_balance(balance:, date: Date.current, currency: nil, notes: nil) - Account::BalanceUpdater.new(self, balance:, currency:, date:, notes:).update - end - def start_date first_entry_date = entries.minimum(:date) || Date.current first_entry_date - 1.day @@ -159,4 +141,23 @@ def short_subtype_label def long_subtype_label accountable_class.long_subtype_label_for(subtype) || accountable_class.display_name end + + # The balance type determines which "component" of balance is being tracked. + # This is primarily used for balance related calculations and updates. + # + # "Cash" = "Liquid" + # "Non-cash" = "Illiquid" + # "Investment" = A mix of both, including brokerage cash (liquid) and holdings (illiquid) + def balance_type + case accountable_type + when "Depository", "CreditCard" + :cash + when "Property", "Vehicle", "OtherAsset", "Loan", "OtherLiability" + :non_cash + when "Investment", "Crypto" + :investment + else + raise "Unknown account type: #{accountable_type}" + end + end end diff --git a/app/models/account/activity_feed_data.rb b/app/models/account/activity_feed_data.rb new file mode 100644 index 00000000000..7d1c41bdfa5 --- /dev/null +++ b/app/models/account/activity_feed_data.rb @@ -0,0 +1,85 @@ +# Data used to build the paginated feed of account "activity" (events like transfers, deposits, withdrawals, etc.) +# This data object is useful for avoiding N+1 queries and having an easy way to pass around the required data to the +# activity feed component in controllers and background jobs that refresh it. +class Account::ActivityFeedData + ActivityDateData = Data.define(:date, :entries, :balance, :transfers) + + attr_reader :account, :entries + + def initialize(account, entries) + @account = account + @entries = entries.to_a + end + + def entries_by_date + @entries_by_date_objects ||= begin + grouped_entries.map do |date, date_entries| + ActivityDateData.new( + date: date, + entries: date_entries, + balance: balance_for_date(date), + transfers: transfers_for_date(date) + ) + end + end + end + + private + def balance_for_date(date) + balances_by_date[date] + end + + def transfers_for_date(date) + transfers_by_date[date] || [] + end + + def grouped_entries + @grouped_entries ||= entries.group_by(&:date) + end + + def balances_by_date + @balances_by_date ||= begin + return {} if entries.empty? + + dates = grouped_entries.keys + account.balances + .where(date: dates, currency: account.currency) + .index_by(&:date) + end + end + + def transfers_by_date + @transfers_by_date ||= begin + return {} if transaction_ids.empty? + + transfers = Transfer + .where(inflow_transaction_id: transaction_ids) + .or(Transfer.where(outflow_transaction_id: transaction_ids)) + .to_a + + # Group transfers by the date of their transaction entries + result = Hash.new { |h, k| h[k] = [] } + + entries.each do |entry| + next unless entry.transaction? && transaction_ids.include?(entry.entryable_id) + + transfers.each do |transfer| + if transfer.inflow_transaction_id == entry.entryable_id || + transfer.outflow_transaction_id == entry.entryable_id + result[entry.date] << transfer + end + end + end + + # Remove duplicates + result.transform_values(&:uniq) + end + end + + def transaction_ids + @transaction_ids ||= entries + .select(&:transaction?) + .map(&:entryable_id) + .compact + end +end diff --git a/app/models/account/anchorable.rb b/app/models/account/anchorable.rb new file mode 100644 index 00000000000..bb797c8515a --- /dev/null +++ b/app/models/account/anchorable.rb @@ -0,0 +1,56 @@ +# All accounts are "anchored" with start/end valuation records, with transactions, +# trades, and reconciliations between them. +module Account::Anchorable + extend ActiveSupport::Concern + + included do + include Monetizable + + monetize :opening_balance + end + + def set_opening_anchor_balance(**opts) + result = opening_balance_manager.set_opening_balance(**opts) + sync_later if result.success? + result + end + + def opening_anchor_date + opening_balance_manager.opening_date + end + + def opening_anchor_balance + opening_balance_manager.opening_balance + end + + def has_opening_anchor? + opening_balance_manager.has_opening_anchor? + end + + def set_current_balance(balance) + result = current_balance_manager.set_current_balance(balance) + sync_later if result.success? + result + end + + def current_anchor_balance + current_balance_manager.current_balance + end + + def current_anchor_date + current_balance_manager.current_date + end + + def has_current_anchor? + current_balance_manager.has_current_anchor? + end + + private + def opening_balance_manager + @opening_balance_manager ||= Account::OpeningBalanceManager.new(self) + end + + def current_balance_manager + @current_balance_manager ||= Account::CurrentBalanceManager.new(self) + end +end diff --git a/app/models/account/balance_updater.rb b/app/models/account/balance_updater.rb deleted file mode 100644 index a8100d9b279..00000000000 --- a/app/models/account/balance_updater.rb +++ /dev/null @@ -1,47 +0,0 @@ -class Account::BalanceUpdater - def initialize(account, balance:, currency: nil, date: Date.current, notes: nil) - @account = account - @balance = balance.to_d - @currency = currency - @date = date.to_date - @notes = notes - end - - def update - return Result.new(success?: true, updated?: false) unless requires_update? - - Account.transaction do - if date == Date.current - account.balance = balance - account.currency = currency if currency.present? - account.save! - end - - valuation_entry = account.entries.valuations.find_or_initialize_by(date: date) do |entry| - entry.entryable = Valuation.new - end - - valuation_entry.amount = balance - valuation_entry.currency = currency if currency.present? - valuation_entry.name = Valuation.build_reconciliation_name(account.accountable_type) - valuation_entry.notes = notes if notes.present? - valuation_entry.save! - end - - account.sync_later - - Result.new(success?: true, updated?: true) - rescue => e - message = Rails.env.development? ? e.message : "Unable to update account values. Please try again." - Result.new(success?: false, updated?: false, error_message: message) - end - - private - attr_reader :account, :balance, :currency, :date, :notes - - Result = Struct.new(:success?, :updated?, :error_message) - - def requires_update? - date != Date.current || account.balance != balance || account.currency != currency - end -end diff --git a/app/models/account/current_balance_manager.rb b/app/models/account/current_balance_manager.rb new file mode 100644 index 00000000000..2b1ba630948 --- /dev/null +++ b/app/models/account/current_balance_manager.rb @@ -0,0 +1,141 @@ +class Account::CurrentBalanceManager + InvalidOperation = Class.new(StandardError) + + Result = Struct.new(:success?, :changes_made?, :error, keyword_init: true) + + def initialize(account) + @account = account + end + + def has_current_anchor? + current_anchor_valuation.present? + end + + # Our system should always make sure there is a current anchor, and that it is up to date. + # The fallback is provided for backwards compatibility, but should not be relied on since account.balance is a "cached/derived" value. + def current_balance + if current_anchor_valuation + current_anchor_valuation.entry.amount + else + Rails.logger.warn "No current balance anchor found for account #{account.id}. Using cached balance instead, which may be out of date." + account.balance + end + end + + def current_date + if current_anchor_valuation + current_anchor_valuation.entry.date + else + Date.current + end + end + + def set_current_balance(balance) + if account.linked? + result = set_current_balance_for_linked_account(balance) + else + result = set_current_balance_for_manual_account(balance) + end + + # Update cache field so changes appear immediately to the user + account.update!(balance: balance) + + result + rescue => e + Result.new(success?: false, changes_made?: false, error: e.message) + end + + private + attr_reader :account + + def opening_balance_manager + @opening_balance_manager ||= Account::OpeningBalanceManager.new(account) + end + + def reconciliation_manager + @reconciliation_manager ||= Account::ReconciliationManager.new(account) + end + + # Manual accounts do not manage the `current_anchor` valuation (otherwise, user would need to continually update it, which is bad UX) + # Instead, we use a combination of "auto-update strategies" to set the current balance according to the user's intent. + # + # The "auto-update strategies" are: + # 1. Value tracking - If the account has a reconciliation already, we assume they are tracking the account value primarily with reconciliations, so we append a new one + # 2. Transaction adjustment - If the account doesn't have recons, we assume user is tracking with transactions, so we adjust the opening balance with a delta until it + # gets us to the desired balance. This ensures we don't append unnecessary reconciliations to the account, which "reset" the value from that + # date forward (not user's intent). + # + # For more documentation on these auto-update strategies, see the test cases. + def set_current_balance_for_manual_account(balance) + # If we're dealing with a cash account that has no reconciliations, use "Transaction adjustment" strategy (update opening balance to "back in" to the desired current balance) + if account.balance_type == :cash && account.valuations.reconciliation.empty? + adjust_opening_balance_with_delta(new_balance: balance, old_balance: account.balance) + else + existing_reconciliation = account.entries.valuations.find_by(date: Date.current) + + result = reconciliation_manager.reconcile_balance(balance: balance, date: Date.current, existing_valuation_entry: existing_reconciliation) + + # Normalize to expected result format + Result.new(success?: result.success?, changes_made?: true, error: result.error_message) + end + end + + def adjust_opening_balance_with_delta(new_balance:, old_balance:) + delta = new_balance - old_balance + + result = opening_balance_manager.set_opening_balance(balance: account.opening_anchor_balance + delta) + + # Normalize to expected result format + Result.new(success?: result.success?, changes_made?: true, error: result.error) + end + + # Linked accounts manage "current balance" via the special `current_anchor` valuation. + # This is NOT a user-facing feature, and is primarily used in "processors" while syncing + # linked account data (e.g. via Plaid) + def set_current_balance_for_linked_account(balance) + if current_anchor_valuation + changes_made = update_current_anchor(balance) + Result.new(success?: true, changes_made?: changes_made, error: nil) + else + create_current_anchor(balance) + Result.new(success?: true, changes_made?: true, error: nil) + end + end + + def current_anchor_valuation + @current_anchor_valuation ||= account.valuations.current_anchor.includes(:entry).first + end + + def create_current_anchor(balance) + account.entries.create!( + date: Date.current, + name: Valuation.build_current_anchor_name(account.accountable_type), + amount: balance, + currency: account.currency, + entryable: Valuation.new(kind: "current_anchor") + ) + end + + def update_current_anchor(balance) + changes_made = false + + ActiveRecord::Base.transaction do + # Update associated entry attributes + entry = current_anchor_valuation.entry + + if entry.amount != balance + entry.amount = balance + changes_made = true + end + + if entry.date != Date.current + entry.date = Date.current + changes_made = true + end + + entry.save! if entry.changed? + end + + changes_made + end +end diff --git a/app/models/account/linkable.rb b/app/models/account/linkable.rb index ee0871bde21..76b41bb1011 100644 --- a/app/models/account/linkable.rb +++ b/app/models/account/linkable.rb @@ -15,4 +15,5 @@ def linked? def unlinked? !linked? end + alias_method :manual?, :unlinked? end diff --git a/app/models/account/opening_balance_manager.rb b/app/models/account/opening_balance_manager.rb new file mode 100644 index 00000000000..95597cdaaf3 --- /dev/null +++ b/app/models/account/opening_balance_manager.rb @@ -0,0 +1,99 @@ +class Account::OpeningBalanceManager + Result = Struct.new(:success?, :changes_made?, :error, keyword_init: true) + + def initialize(account) + @account = account + end + + def has_opening_anchor? + opening_anchor_valuation.present? + end + + # Most accounts should have an opening anchor. If not, we derive the opening date from the oldest entry date + def opening_date + return opening_anchor_valuation.entry.date if opening_anchor_valuation.present? + + [ + account.entries.valuations.order(:date).first&.date, + account.entries.where.not(entryable_type: "Valuation").order(:date).first&.date&.prev_day + ].compact.min || Date.current + end + + def opening_balance + opening_anchor_valuation&.entry&.amount || 0 + end + + def set_opening_balance(balance:, date: nil) + resolved_date = date || default_date + + # Validate date is before oldest entry + if date && oldest_entry_date && resolved_date >= oldest_entry_date + return Result.new(success?: false, changes_made?: false, error: "Opening balance date must be before the oldest entry date") + end + + if opening_anchor_valuation.nil? + create_opening_anchor( + balance: balance, + date: resolved_date + ) + Result.new(success?: true, changes_made?: true, error: nil) + else + changes_made = update_opening_anchor(balance: balance, date: date) + Result.new(success?: true, changes_made?: changes_made, error: nil) + end + end + + private + attr_reader :account + + def opening_anchor_valuation + @opening_anchor_valuation ||= account.valuations.opening_anchor.includes(:entry).first + end + + def oldest_entry_date + @oldest_entry_date ||= account.entries.minimum(:date) + end + + def default_date + if oldest_entry_date + [ oldest_entry_date - 1.day, 2.years.ago.to_date ].min + else + 2.years.ago.to_date + end + end + + def create_opening_anchor(balance:, date:) + account.entries.create!( + date: date, + name: Valuation.build_opening_anchor_name(account.accountable_type), + amount: balance, + currency: account.currency, + entryable: Valuation.new( + kind: "opening_anchor" + ) + ) + end + + def update_opening_anchor(balance:, date: nil) + changes_made = false + + ActiveRecord::Base.transaction do + # Update associated entry attributes + entry = opening_anchor_valuation.entry + + if entry.amount != balance + entry.amount = balance + changes_made = true + end + + if date.present? && entry.date != date + entry.date = date + changes_made = true + end + + entry.save! if entry.changed? + end + + changes_made + end +end diff --git a/app/models/account/reconcileable.rb b/app/models/account/reconcileable.rb new file mode 100644 index 00000000000..67a6b52c63b --- /dev/null +++ b/app/models/account/reconcileable.rb @@ -0,0 +1,20 @@ +module Account::Reconcileable + extend ActiveSupport::Concern + + def create_reconciliation(balance:, date:, dry_run: false) + result = reconciliation_manager.reconcile_balance(balance: balance, date: date, dry_run: dry_run) + sync_later if result.success? && !dry_run + result + end + + def update_reconciliation(existing_valuation_entry, balance:, date:, dry_run: false) + result = reconciliation_manager.reconcile_balance(balance: balance, date: date, existing_valuation_entry: existing_valuation_entry, dry_run: dry_run) + sync_later if result.success? && !dry_run + result + end + + private + def reconciliation_manager + @reconciliation_manager ||= Account::ReconciliationManager.new(self) + end +end diff --git a/app/models/account/reconciliation_manager.rb b/app/models/account/reconciliation_manager.rb new file mode 100644 index 00000000000..6fadcfa1a2f --- /dev/null +++ b/app/models/account/reconciliation_manager.rb @@ -0,0 +1,89 @@ +class Account::ReconciliationManager + attr_reader :account + + def initialize(account) + @account = account + end + + # Reconciles balance by creating a Valuation entry. If existing valuation is provided, it will be updated instead of creating a new one. + def reconcile_balance(balance:, date: Date.current, dry_run: false, existing_valuation_entry: nil) + old_balance_components = old_balance_components(reconciliation_date: date, existing_valuation_entry: existing_valuation_entry) + prepared_valuation = prepare_reconciliation(balance, date, existing_valuation_entry) + + unless dry_run + prepared_valuation.save! + end + + ReconciliationResult.new( + success?: true, + old_cash_balance: old_balance_components[:cash_balance], + old_balance: old_balance_components[:balance], + new_cash_balance: derived_cash_balance(date: date, total_balance: prepared_valuation.amount), + new_balance: prepared_valuation.amount, + error_message: nil + ) + rescue => e + ReconciliationResult.new( + success?: false, + error_message: e.message + ) + end + + private + # Returns before -> after OR error message + ReconciliationResult = Struct.new( + :success?, + :old_cash_balance, + :old_balance, + :new_cash_balance, + :new_balance, + :error_message, + keyword_init: true + ) + + def prepare_reconciliation(balance, date, existing_valuation) + valuation_record = existing_valuation || + account.entries.valuations.find_by(date: date) || # In case of conflict, where existing valuation is not passed as arg, but one exists + account.entries.build( + name: Valuation.build_reconciliation_name(account.accountable_type), + entryable: Valuation.new(kind: "reconciliation") + ) + + valuation_record.assign_attributes( + date: date, + amount: balance, + currency: account.currency + ) + + valuation_record + end + + def derived_cash_balance(date:, total_balance:) + balance_components_for_reconciliation_date = get_balance_components_for_date(date) + + return nil unless balance_components_for_reconciliation_date[:balance] && balance_components_for_reconciliation_date[:cash_balance] + + # We calculate the existing non-cash balance, which for investments would represents "holdings" for the date of reconciliation + # Since the user is setting "total balance", we have to subtract the existing non-cash balance from the total balance to get the new cash balance + existing_non_cash_balance = balance_components_for_reconciliation_date[:balance] - balance_components_for_reconciliation_date[:cash_balance] + + total_balance - existing_non_cash_balance + end + + def old_balance_components(reconciliation_date:, existing_valuation_entry: nil) + if existing_valuation_entry + get_balance_components_for_date(existing_valuation_entry.date) + else + get_balance_components_for_date(reconciliation_date) + end + end + + def get_balance_components_for_date(date) + balance_record = account.balances.find_by(date: date, currency: account.currency) + + { + cash_balance: balance_record&.end_cash_balance, + balance: balance_record&.end_balance + } + end +end diff --git a/app/models/account_import.rb b/app/models/account_import.rb index 4836ce550f7..0ffdcec4cd4 100644 --- a/app/models/account_import.rb +++ b/app/models/account_import.rb @@ -1,4 +1,6 @@ class AccountImport < Import + OpeningBalanceError = Class.new(StandardError) + def import! transaction do rows.each do |row| @@ -15,13 +17,13 @@ def import! account.save! - account.entries.create!( - amount: row.amount, - currency: row.currency, - date: 2.years.ago.to_date, - name: Valuation.build_opening_anchor_name(account.accountable_type), - entryable: Valuation.new - ) + manager = Account::OpeningBalanceManager.new(account) + result = manager.set_opening_balance(balance: row.amount.to_d) + + # Re-raise since we should never have an error here + if result.error + raise OpeningBalanceError, result.error + end end end end diff --git a/app/models/assistant/function/get_transactions.rb b/app/models/assistant/function/get_transactions.rb index 9b0da316921..7ad081fbc2d 100644 --- a/app/models/assistant/function/get_transactions.rb +++ b/app/models/assistant/function/get_transactions.rb @@ -134,7 +134,8 @@ def params_schema def call(params = {}) search_params = params.except("order", "page") - transactions_query = family.transactions.visible.search(search_params) + search = Transaction::Search.new(family, filters: search_params) + transactions_query = search.transactions_scope pagy_query = params["order"] == "asc" ? transactions_query.chronological : transactions_query.reverse_chronological # By default, we give a small page size to force the AI to use filters effectively and save on tokens @@ -149,7 +150,7 @@ def call(params = {}) limit: default_page_size ) - totals = family.income_statement.totals(transactions_scope: transactions_query) + totals = search.totals normalized_transactions = paginated_transactions.map do |txn| entry = txn.entry diff --git a/app/models/balance.rb b/app/models/balance.rb index 90c4df41e16..3b6f74ce21c 100644 --- a/app/models/balance.rb +++ b/app/models/balance.rb @@ -2,8 +2,30 @@ class Balance < ApplicationRecord include Monetizable belongs_to :account + validates :account, :date, :balance, presence: true - monetize :balance + validates :flows_factor, inclusion: { in: [ -1, 1 ] } + + monetize :balance, :cash_balance, + :start_cash_balance, :start_non_cash_balance, :start_balance, + :cash_inflows, :cash_outflows, :non_cash_inflows, :non_cash_outflows, :net_market_flows, + :cash_adjustments, :non_cash_adjustments, + :end_cash_balance, :end_non_cash_balance, :end_balance + scope :in_period, ->(period) { period.nil? ? all : where(date: period.date_range) } scope :chronological, -> { order(:date) } + + def balance_trend + Trend.new( + current: end_balance_money, + previous: start_balance_money, + favorable_direction: favorable_direction + ) + end + + private + + def favorable_direction + flows_factor == -1 ? "down" : "up" + end end diff --git a/app/models/balance/base_calculator.rb b/app/models/balance/base_calculator.rb new file mode 100644 index 00000000000..a1e43d99e4f --- /dev/null +++ b/app/models/balance/base_calculator.rb @@ -0,0 +1,140 @@ +class Balance::BaseCalculator + attr_reader :account + + def initialize(account) + @account = account + end + + def calculate + raise NotImplementedError, "Subclasses must implement this method" + end + + private + def sync_cache + @sync_cache ||= Balance::SyncCache.new(account) + end + + def holdings_value_for_date(date) + @holdings_value_for_date ||= {} + @holdings_value_for_date[date] ||= sync_cache.get_holdings(date).sum(&:amount) + end + + def derive_cash_balance_on_date_from_total(total_balance:, date:) + if account.balance_type == :investment + total_balance - holdings_value_for_date(date) + elsif account.balance_type == :cash + total_balance + else + 0 + end + end + + def cash_adjustments_for_date(start_cash, end_cash, net_cash_flows) + return 0 unless account.balance_type != :non_cash + + end_cash - start_cash - net_cash_flows + end + + def non_cash_adjustments_for_date(start_non_cash, end_non_cash, non_cash_flows) + return 0 unless account.balance_type == :non_cash + + end_non_cash - start_non_cash - non_cash_flows + end + + # If holdings value goes from $100 -> $200 (change_holdings_value is $100) + # And non-cash flows (i.e. "buys") for day are +$50 (net_buy_sell_value is $50) + # That means value increased by $100, where $50 of that is due to the change in holdings value, and $50 is due to the buy/sell + def market_value_change_on_date(date, flows) + return 0 unless account.balance_type == :investment + + start_of_day_holdings_value = holdings_value_for_date(date.prev_day) + end_of_day_holdings_value = holdings_value_for_date(date) + + change_holdings_value = end_of_day_holdings_value - start_of_day_holdings_value + net_buy_sell_value = flows[:non_cash_inflows] - flows[:non_cash_outflows] + + change_holdings_value - net_buy_sell_value + end + + def flows_for_date(date) + entries = sync_cache.get_entries(date) + + cash_inflows = 0 + cash_outflows = 0 + non_cash_inflows = 0 + non_cash_outflows = 0 + + txn_inflow_sum = entries.select { |e| e.amount < 0 && e.transaction? }.sum(&:amount) + txn_outflow_sum = entries.select { |e| e.amount >= 0 && e.transaction? }.sum(&:amount) + + trade_cash_inflow_sum = entries.select { |e| e.amount < 0 && e.trade? }.sum(&:amount) + trade_cash_outflow_sum = entries.select { |e| e.amount >= 0 && e.trade? }.sum(&:amount) + + if account.balance_type == :non_cash && account.accountable_type == "Loan" + non_cash_inflows = txn_inflow_sum.abs + non_cash_outflows = txn_outflow_sum + elsif account.balance_type != :non_cash + cash_inflows = txn_inflow_sum.abs + trade_cash_inflow_sum.abs + cash_outflows = txn_outflow_sum + trade_cash_outflow_sum + + # Trades are inverse (a "buy" is outflow of cash, but "inflow" of non-cash, aka "holdings") + non_cash_outflows = trade_cash_inflow_sum.abs + non_cash_inflows = trade_cash_outflow_sum + end + + { + cash_inflows: cash_inflows, + cash_outflows: cash_outflows, + non_cash_inflows: non_cash_inflows, + non_cash_outflows: non_cash_outflows + } + end + + def derive_cash_balance(cash_balance, date) + entries = sync_cache.get_entries(date) + + if account.balance_type == :non_cash + 0 + else + cash_balance + signed_entry_flows(entries) + end + end + + def derive_non_cash_balance(non_cash_balance, date, direction: :forward) + entries = sync_cache.get_entries(date) + # Loans are a special case (loan payment reducing principal, which is non-cash) + if account.balance_type == :non_cash && account.accountable_type == "Loan" + non_cash_balance + signed_entry_flows(entries) + elsif account.balance_type == :investment + # For reverse calculations, we need the previous day's holdings + target_date = direction == :forward ? date : date.prev_day + holdings_value_for_date(target_date) + else + non_cash_balance + end + end + + def signed_entry_flows(entries) + raise NotImplementedError, "Directional calculators must implement this method" + end + + def build_balance(date:, **args) + Balance.new( + account_id: account.id, + currency: account.currency, + date: date, + balance: args[:balance], + cash_balance: args[:cash_balance], + start_cash_balance: args[:start_cash_balance] || 0, + start_non_cash_balance: args[:start_non_cash_balance] || 0, + cash_inflows: args[:cash_inflows] || 0, + cash_outflows: args[:cash_outflows] || 0, + non_cash_inflows: args[:non_cash_inflows] || 0, + non_cash_outflows: args[:non_cash_outflows] || 0, + cash_adjustments: args[:cash_adjustments] || 0, + non_cash_adjustments: args[:non_cash_adjustments] || 0, + net_market_flows: args[:net_market_flows] || 0, + flows_factor: account.classification == "asset" ? 1 : -1 + ) + end +end diff --git a/app/models/balance/chart_series_builder.rb b/app/models/balance/chart_series_builder.rb index 0c367685545..dad1081718f 100644 --- a/app/models/balance/chart_series_builder.rb +++ b/app/models/balance/chart_series_builder.rb @@ -8,21 +8,21 @@ def initialize(account_ids:, currency:, period: Period.last_30_days, interval: " end def balance_series - build_series_for(:balance) + build_series_for(:end_balance) rescue => e Rails.logger.error "Balance series error: #{e.message} for accounts #{@account_ids}" raise end def cash_balance_series - build_series_for(:cash_balance) + build_series_for(:end_cash_balance) rescue => e Rails.logger.error "Cash balance series error: #{e.message} for accounts #{@account_ids}" raise end def holdings_balance_series - build_series_for(:holdings_balance) + build_series_for(:end_holdings_balance) rescue => e Rails.logger.error "Holdings balance series error: #{e.message} for accounts #{@account_ids}" raise @@ -37,13 +37,20 @@ def interval def build_series_for(column) values = query_data.map do |datum| + # Map column names to their start equivalents + previous_column = case column + when :end_balance then :start_balance + when :end_cash_balance then :start_cash_balance + when :end_holdings_balance then :start_holdings_balance + end + Series::Value.new( date: datum.date, date_formatted: I18n.l(datum.date, format: :long), value: Money.new(datum.send(column), currency), trend: Trend.new( current: Money.new(datum.send(column), currency), - previous: Money.new(datum.send("previous_#{column}"), currency), + previous: Money.new(datum.send(previous_column), currency), favorable_direction: favorable_direction ) ) @@ -88,66 +95,57 @@ def query WITH dates AS ( SELECT generate_series(DATE :start_date, DATE :end_date, :interval::interval)::date AS date UNION DISTINCT - SELECT :end_date::date -- Pass in date to ensure timezone-aware "today" date - ), aggregated_balances AS ( - SELECT - d.date, - -- Total balance (assets positive, liabilities negative) - SUM( - CASE WHEN accounts.classification = 'asset' - THEN COALESCE(last_bal.balance, 0) - ELSE -COALESCE(last_bal.balance, 0) - END * COALESCE(er.rate, 1) * :sign_multiplier::integer - ) AS balance, - -- Cash-only balance - SUM( - CASE WHEN accounts.classification = 'asset' - THEN COALESCE(last_bal.cash_balance, 0) - ELSE -COALESCE(last_bal.cash_balance, 0) - END * COALESCE(er.rate, 1) * :sign_multiplier::integer - ) AS cash_balance, - -- Holdings value (balance ‑ cash) - SUM( - CASE WHEN accounts.classification = 'asset' - THEN COALESCE(last_bal.balance, 0) - COALESCE(last_bal.cash_balance, 0) - ELSE 0 - END * COALESCE(er.rate, 1) * :sign_multiplier::integer - ) AS holdings_balance - FROM dates d - JOIN accounts ON accounts.id = ANY(array[:account_ids]::uuid[]) - - -- Last observation carried forward (LOCF), use the most recent balance on or before the chart date - LEFT JOIN LATERAL ( - SELECT b.balance, b.cash_balance - FROM balances b - WHERE b.account_id = accounts.id - AND b.date <= d.date - ORDER BY b.date DESC - LIMIT 1 - ) last_bal ON TRUE - - -- Last observation carried forward (LOCF), use the most recent exchange rate on or before the chart date - LEFT JOIN LATERAL ( - SELECT er.rate - FROM exchange_rates er - WHERE er.from_currency = accounts.currency - AND er.to_currency = :target_currency - AND er.date <= d.date - ORDER BY er.date DESC - LIMIT 1 - ) er ON TRUE - GROUP BY d.date + SELECT :end_date::date -- Ensure end date is included ) SELECT - date, - balance, - cash_balance, - holdings_balance, - COALESCE(LAG(balance) OVER (ORDER BY date), 0) AS previous_balance, - COALESCE(LAG(cash_balance) OVER (ORDER BY date), 0) AS previous_cash_balance, - COALESCE(LAG(holdings_balance) OVER (ORDER BY date), 0) AS previous_holdings_balance - FROM aggregated_balances - ORDER BY date + d.date, + -- Use flows_factor: already handles asset (+1) vs liability (-1) + COALESCE(SUM(last_bal.end_balance * last_bal.flows_factor * COALESCE(er.rate, 1) * :sign_multiplier::integer), 0) AS end_balance, + COALESCE(SUM(last_bal.end_cash_balance * last_bal.flows_factor * COALESCE(er.rate, 1) * :sign_multiplier::integer), 0) AS end_cash_balance, + -- Holdings only for assets (flows_factor = 1) + COALESCE(SUM( + CASE WHEN last_bal.flows_factor = 1 + THEN last_bal.end_non_cash_balance + ELSE 0 + END * COALESCE(er.rate, 1) * :sign_multiplier::integer + ), 0) AS end_holdings_balance, + -- Previous balances + COALESCE(SUM(last_bal.start_balance * last_bal.flows_factor * COALESCE(er.rate, 1) * :sign_multiplier::integer), 0) AS start_balance, + COALESCE(SUM(last_bal.start_cash_balance * last_bal.flows_factor * COALESCE(er.rate, 1) * :sign_multiplier::integer), 0) AS start_cash_balance, + COALESCE(SUM( + CASE WHEN last_bal.flows_factor = 1 + THEN last_bal.start_non_cash_balance + ELSE 0 + END * COALESCE(er.rate, 1) * :sign_multiplier::integer + ), 0) AS start_holdings_balance + FROM dates d + CROSS JOIN accounts + LEFT JOIN LATERAL ( + SELECT b.end_balance, + b.end_cash_balance, + b.end_non_cash_balance, + b.start_balance, + b.start_cash_balance, + b.start_non_cash_balance, + b.flows_factor + FROM balances b + WHERE b.account_id = accounts.id + AND b.date <= d.date + ORDER BY b.date DESC + LIMIT 1 + ) last_bal ON TRUE + LEFT JOIN LATERAL ( + SELECT er.rate + FROM exchange_rates er + WHERE er.from_currency = accounts.currency + AND er.to_currency = :target_currency + AND er.date <= d.date + ORDER BY er.date DESC + LIMIT 1 + ) er ON TRUE + WHERE accounts.id = ANY(array[:account_ids]::uuid[]) + GROUP BY d.date + ORDER BY d.date SQL end end diff --git a/app/models/balance/forward_calculator.rb b/app/models/balance/forward_calculator.rb index 4e6f2d5c4d8..af092a2a379 100644 --- a/app/models/balance/forward_calculator.rb +++ b/app/models/balance/forward_calculator.rb @@ -1,61 +1,85 @@ -class Balance::ForwardCalculator - attr_reader :account - - def initialize(account) - @account = account - end - +class Balance::ForwardCalculator < Balance::BaseCalculator def calculate Rails.logger.tagged("Balance::ForwardCalculator") do - calculate_balances - end - end - - private - def calculate_balances - current_cash_balance = 0 - next_cash_balance = nil - - @balances = [] + start_cash_balance = derive_cash_balance_on_date_from_total( + total_balance: account.opening_anchor_balance, + date: account.opening_anchor_date + ) + start_non_cash_balance = account.opening_anchor_balance - start_cash_balance - account.start_date.upto(Date.current).each do |date| - entries = sync_cache.get_entries(date) - holdings = sync_cache.get_holdings(date) - holdings_value = holdings.sum(&:amount) + calc_start_date.upto(calc_end_date).map do |date| valuation = sync_cache.get_valuation(date) - next_cash_balance = if valuation - valuation.amount - holdings_value + if valuation + end_cash_balance = derive_cash_balance_on_date_from_total( + total_balance: valuation.amount, + date: date + ) + end_non_cash_balance = valuation.amount - end_cash_balance else - calculate_next_balance(current_cash_balance, entries, direction: :forward) + end_cash_balance = derive_end_cash_balance(start_cash_balance: start_cash_balance, date: date) + end_non_cash_balance = derive_end_non_cash_balance(start_non_cash_balance: start_non_cash_balance, date: date) end - @balances << build_balance(date, next_cash_balance, holdings_value) + flows = flows_for_date(date) + market_value_change = market_value_change_on_date(date, flows) + + cash_adjustments = cash_adjustments_for_date(start_cash_balance, end_cash_balance, (flows[:cash_inflows] - flows[:cash_outflows]) * flows_factor) + non_cash_adjustments = non_cash_adjustments_for_date(start_non_cash_balance, end_non_cash_balance, (flows[:non_cash_inflows] - flows[:non_cash_outflows]) * flows_factor) - current_cash_balance = next_cash_balance + output_balance = build_balance( + date: date, + balance: end_cash_balance + end_non_cash_balance, + cash_balance: end_cash_balance, + start_cash_balance: start_cash_balance, + start_non_cash_balance: start_non_cash_balance, + cash_inflows: flows[:cash_inflows], + cash_outflows: flows[:cash_outflows], + non_cash_inflows: flows[:non_cash_inflows], + non_cash_outflows: flows[:non_cash_outflows], + cash_adjustments: cash_adjustments, + non_cash_adjustments: non_cash_adjustments, + net_market_flows: market_value_change + ) + + # Set values for the next iteration + start_cash_balance = end_cash_balance + start_non_cash_balance = end_non_cash_balance + + output_balance end + end + end + + private + def calc_start_date + account.opening_anchor_date + end - @balances + def calc_end_date + [ account.entries.order(:date).last&.date, account.holdings.order(:date).last&.date ].compact.max || Date.current end - def sync_cache - @sync_cache ||= Balance::SyncCache.new(account) + # Negative entries amount on an "asset" account means, "account value has increased" + # Negative entries amount on a "liability" account means, "account debt has decreased" + # Positive entries amount on an "asset" account means, "account value has decreased" + # Positive entries amount on a "liability" account means, "account debt has increased" + def signed_entry_flows(entries) + entry_flows = entries.sum(&:amount) + account.asset? ? -entry_flows : entry_flows end - def build_balance(date, cash_balance, holdings_value) - Balance.new( - account_id: account.id, - date: date, - balance: holdings_value + cash_balance, - cash_balance: cash_balance, - currency: account.currency - ) + # Derives cash balance, starting from the start-of-day, applying entries in forward to get the end-of-day balance + def derive_end_cash_balance(start_cash_balance:, date:) + derive_cash_balance(start_cash_balance, date) + end + + # Derives non-cash balance, starting from the start-of-day, applying entries in forward to get the end-of-day balance + def derive_end_non_cash_balance(start_non_cash_balance:, date:) + derive_non_cash_balance(start_non_cash_balance, date, direction: :forward) end - def calculate_next_balance(prior_balance, transactions, direction: :forward) - flows = transactions.sum(&:amount) - negated = direction == :forward ? account.asset? : account.liability? - flows *= -1 if negated - prior_balance + flows + def flows_factor + account.asset? ? 1 : -1 end end diff --git a/app/models/balance/materializer.rb b/app/models/balance/materializer.rb index 75a98ffdd59..c6501ffa11a 100644 --- a/app/models/balance/materializer.rb +++ b/app/models/balance/materializer.rb @@ -28,9 +28,20 @@ def materialize_holdings end def update_account_info - calculated_balance = @balances.sort_by(&:date).last&.balance || 0 - calculated_holdings_value = @holdings.select { |h| h.date == Date.current }.sum(&:amount) || 0 - calculated_cash_balance = calculated_balance - calculated_holdings_value + # Query fresh balance from DB to get generated column values + current_balance = account.balances + .where(currency: account.currency) + .order(date: :desc) + .first + + if current_balance + calculated_balance = current_balance.end_balance + calculated_cash_balance = current_balance.end_cash_balance + else + # Fallback if no balance exists + calculated_balance = 0 + calculated_cash_balance = 0 + end Rails.logger.info("Balance update: cash=#{calculated_cash_balance}, total=#{calculated_balance}") @@ -48,14 +59,23 @@ def persist_balances current_time = Time.now account.balances.upsert_all( @balances.map { |b| b.attributes - .slice("date", "balance", "cash_balance", "currency") + .slice("date", "balance", "cash_balance", "currency", + "start_cash_balance", "start_non_cash_balance", + "cash_inflows", "cash_outflows", + "non_cash_inflows", "non_cash_outflows", + "net_market_flows", + "cash_adjustments", "non_cash_adjustments", + "flows_factor") .merge("updated_at" => current_time) }, unique_by: %i[account_id date currency] ) end def purge_stale_balances - deleted_count = account.balances.delete_by("date < ?", account.start_date) + sorted_balances = @balances.sort_by(&:date) + oldest_calculated_balance_date = sorted_balances.first&.date + newest_calculated_balance_date = sorted_balances.last&.date + deleted_count = account.balances.delete_by("date < ? OR date > ?", oldest_calculated_balance_date, newest_calculated_balance_date) Rails.logger.info("Purged #{deleted_count} stale balances") if deleted_count > 0 end diff --git a/app/models/balance/reverse_calculator.rb b/app/models/balance/reverse_calculator.rb index 52a05608486..35a774452dd 100644 --- a/app/models/balance/reverse_calculator.rb +++ b/app/models/balance/reverse_calculator.rb @@ -1,71 +1,82 @@ -class Balance::ReverseCalculator - attr_reader :account - - def initialize(account) - @account = account - end - +class Balance::ReverseCalculator < Balance::BaseCalculator def calculate Rails.logger.tagged("Balance::ReverseCalculator") do - calculate_balances - end - end - - private - def calculate_balances - current_cash_balance = account.cash_balance - previous_cash_balance = nil + # Since it's a reverse sync, we're starting with the "end of day" balance components and + # calculating backwards to derive the "start of day" balance components. + end_cash_balance = derive_cash_balance_on_date_from_total( + total_balance: account.current_anchor_balance, + date: account.current_anchor_date + ) + end_non_cash_balance = account.current_anchor_balance - end_cash_balance - @balances = [] + # Calculates in reverse-chronological order (End of day -> Start of day) + account.current_anchor_date.downto(account.opening_anchor_date).map do |date| + flows = flows_for_date(date) - Date.current.downto(account.start_date).map do |date| - entries = sync_cache.get_entries(date) - holdings = sync_cache.get_holdings(date) - holdings_value = holdings.sum(&:amount) - valuation = sync_cache.get_valuation(date) + if use_opening_anchor_for_date?(date) + end_cash_balance = derive_cash_balance_on_date_from_total( + total_balance: account.opening_anchor_balance, + date: date + ) + end_non_cash_balance = account.opening_anchor_balance - end_cash_balance - previous_cash_balance = if valuation - valuation.amount - holdings_value + start_cash_balance = end_cash_balance + start_non_cash_balance = end_non_cash_balance + market_value_change = 0 else - calculate_next_balance(current_cash_balance, entries, direction: :reverse) + start_cash_balance = derive_start_cash_balance(end_cash_balance: end_cash_balance, date: date) + start_non_cash_balance = derive_start_non_cash_balance(end_non_cash_balance: end_non_cash_balance, date: date) + market_value_change = market_value_change_on_date(date, flows) end - if valuation.present? - @balances << build_balance(date, previous_cash_balance, holdings_value) - else - # If date is today, we don't distinguish cash vs. total since provider's are inconsistent with treatment - # of the cash component. Instead, just set the balance equal to the "total value" reported by the provider - if date == Date.current - @balances << build_balance(date, account.cash_balance, account.balance - account.cash_balance) - else - @balances << build_balance(date, current_cash_balance, holdings_value) - end - end + output_balance = build_balance( + date: date, + balance: end_cash_balance + end_non_cash_balance, + cash_balance: end_cash_balance, + start_cash_balance: start_cash_balance, + start_non_cash_balance: start_non_cash_balance, + cash_inflows: flows[:cash_inflows], + cash_outflows: flows[:cash_outflows], + non_cash_inflows: flows[:non_cash_inflows], + non_cash_outflows: flows[:non_cash_outflows], + net_market_flows: market_value_change + ) - current_cash_balance = previous_cash_balance + end_cash_balance = start_cash_balance + end_non_cash_balance = start_non_cash_balance + + output_balance end + end + end + + private - @balances + # Negative entries amount on an "asset" account means, "account value has increased" + # Negative entries amount on a "liability" account means, "account debt has decreased" + # Positive entries amount on an "asset" account means, "account value has decreased" + # Positive entries amount on a "liability" account means, "account debt has increased" + def signed_entry_flows(entries) + entry_flows = entries.sum(&:amount) + account.asset? ? entry_flows : -entry_flows end - def sync_cache - @sync_cache ||= Balance::SyncCache.new(account) + # Alias method, for algorithmic clarity + # Derives cash balance, starting from the end-of-day, applying entries in reverse to get the start-of-day balance + def derive_start_cash_balance(end_cash_balance:, date:) + derive_cash_balance(end_cash_balance, date) end - def build_balance(date, cash_balance, holdings_value) - Balance.new( - account_id: account.id, - date: date, - balance: holdings_value + cash_balance, - cash_balance: cash_balance, - currency: account.currency - ) + # Alias method, for algorithmic clarity + # Derives non-cash balance, starting from the end-of-day, applying entries in reverse to get the start-of-day balance + def derive_start_non_cash_balance(end_non_cash_balance:, date:) + derive_non_cash_balance(end_non_cash_balance, date, direction: :reverse) end - def calculate_next_balance(prior_balance, transactions, direction: :forward) - flows = transactions.sum(&:amount) - negated = direction == :forward ? account.asset? : account.liability? - flows *= -1 if negated - prior_balance + flows + # Reverse syncs are a bit different than forward syncs because we do not allow "reconciliation" valuations + # to be used at all. This is primarily to keep the code and the UI easy to understand. For a more detailed + # explanation, see the test suite. + def use_opening_anchor_for_date?(date) + account.has_opening_anchor? && date == account.opening_anchor_date end end diff --git a/app/models/balance/trend_calculator.rb b/app/models/balance/trend_calculator.rb deleted file mode 100644 index b088d022cd6..00000000000 --- a/app/models/balance/trend_calculator.rb +++ /dev/null @@ -1,30 +0,0 @@ -# The current system calculates a single, end-of-day balance every day for each account for simplicity. -# In most cases, this is sufficient. However, for the "Activity View", we need to show intraday balances -# to show users how each entry affects their balances. This class calculates intraday balances by -# interpolating between end-of-day balances. -class Balance::TrendCalculator - BalanceTrend = Struct.new(:trend, :cash, keyword_init: true) - - def initialize(balances) - @balances = balances - end - - def trend_for(date) - balance = @balances.find { |b| b.date == date } - prior_balance = @balances.find { |b| b.date == date - 1.day } - - return BalanceTrend.new(trend: nil) unless balance.present? - - BalanceTrend.new( - trend: Trend.new( - current: Money.new(balance.balance, balance.currency), - previous: Money.new(prior_balance.balance, balance.currency), - favorable_direction: balance.account.favorable_direction - ), - cash: Money.new(balance.cash_balance, balance.currency), - ) - end - - private - attr_reader :balances -end diff --git a/app/models/budget.rb b/app/models/budget.rb index f8cb991c9d0..acdd128d129 100644 --- a/app/models/budget.rb +++ b/app/models/budget.rb @@ -49,7 +49,10 @@ def find_or_bootstrap(family, start_date:) private def oldest_valid_budget_date(family) - @oldest_valid_budget_date ||= family.oldest_entry_date.beginning_of_month + # Allow going back to either the earliest entry date OR 2 years ago, whichever is earlier + two_years_ago = 2.years.ago.beginning_of_month + oldest_entry_date = family.oldest_entry_date.beginning_of_month + [ two_years_ago, oldest_entry_date ].min end end diff --git a/app/models/concerns/syncable.rb b/app/models/concerns/syncable.rb index 739d53812f9..298aa620759 100644 --- a/app/models/concerns/syncable.rb +++ b/app/models/concerns/syncable.rb @@ -47,7 +47,7 @@ def broadcast_sync_complete end def sync_error - latest_sync&.error + latest_sync&.error || latest_sync&.children&.map(&:error)&.compact&.first end def last_synced_at diff --git a/app/models/demo/generator.rb b/app/models/demo/generator.rb index e12e5b852a3..b530b273691 100644 --- a/app/models/demo/generator.rb +++ b/app/models/demo/generator.rb @@ -1174,7 +1174,7 @@ def reconcile_balances!(family) # Property valuations (these accounts are valued, not transaction-driven) @home.entries.create!( - entryable: Valuation.new, + entryable: Valuation.new(kind: "current_anchor"), amount: 350_000, name: Valuation.build_current_anchor_name(@home.accountable_type), currency: "USD", @@ -1183,7 +1183,7 @@ def reconcile_balances!(family) # Vehicle valuations (these depreciate over time) @honda_accord.entries.create!( - entryable: Valuation.new, + entryable: Valuation.new(kind: "current_anchor"), amount: 18_000, name: Valuation.build_current_anchor_name(@honda_accord.accountable_type), currency: "USD", @@ -1191,7 +1191,7 @@ def reconcile_balances!(family) ) @tesla_model3.entries.create!( - entryable: Valuation.new, + entryable: Valuation.new(kind: "current_anchor"), amount: 4_500, name: Valuation.build_current_anchor_name(@tesla_model3.accountable_type), currency: "USD", @@ -1199,7 +1199,7 @@ def reconcile_balances!(family) ) @jewelry.entries.create!( - entryable: Valuation.new, + entryable: Valuation.new(kind: "reconciliation"), amount: 2000, name: Valuation.build_reconciliation_name(@jewelry.accountable_type), currency: "USD", @@ -1207,7 +1207,7 @@ def reconcile_balances!(family) ) @personal_loc.entries.create!( - entryable: Valuation.new, + entryable: Valuation.new(kind: "reconciliation"), amount: 800, name: Valuation.build_reconciliation_name(@personal_loc.accountable_type), currency: "USD", diff --git a/app/models/family.rb b/app/models/family.rb index 1f35488f91f..7ebec1c4f6e 100644 --- a/app/models/family.rb +++ b/app/models/family.rb @@ -18,6 +18,7 @@ class Family < ApplicationRecord has_many :invitations, dependent: :destroy has_many :imports, dependent: :destroy + has_many :family_exports, dependent: :destroy has_many :entries, through: :accounts has_many :transactions, through: :accounts diff --git a/app/models/family/data_exporter.rb b/app/models/family/data_exporter.rb new file mode 100644 index 00000000000..93546cd6df0 --- /dev/null +++ b/app/models/family/data_exporter.rb @@ -0,0 +1,238 @@ +require "zip" +require "csv" + +class Family::DataExporter + def initialize(family) + @family = family + end + + def generate_export + # Create a StringIO to hold the zip data in memory + zip_data = Zip::OutputStream.write_buffer do |zipfile| + # Add accounts.csv + zipfile.put_next_entry("accounts.csv") + zipfile.write generate_accounts_csv + + # Add transactions.csv + zipfile.put_next_entry("transactions.csv") + zipfile.write generate_transactions_csv + + # Add trades.csv + zipfile.put_next_entry("trades.csv") + zipfile.write generate_trades_csv + + # Add categories.csv + zipfile.put_next_entry("categories.csv") + zipfile.write generate_categories_csv + + # Add all.ndjson + zipfile.put_next_entry("all.ndjson") + zipfile.write generate_ndjson + end + + # Rewind and return the StringIO + zip_data.rewind + zip_data + end + + private + + def generate_accounts_csv + CSV.generate do |csv| + csv << [ "id", "name", "type", "subtype", "balance", "currency", "created_at" ] + + # Only export accounts belonging to this family + @family.accounts.includes(:accountable).find_each do |account| + csv << [ + account.id, + account.name, + account.accountable_type, + account.subtype, + account.balance.to_s, + account.currency, + account.created_at.iso8601 + ] + end + end + end + + def generate_transactions_csv + CSV.generate do |csv| + csv << [ "date", "account_name", "amount", "name", "category", "tags", "notes", "currency" ] + + # Only export transactions from accounts belonging to this family + @family.transactions + .includes(:category, :tags, entry: :account) + .find_each do |transaction| + csv << [ + transaction.entry.date.iso8601, + transaction.entry.account.name, + transaction.entry.amount.to_s, + transaction.entry.name, + transaction.category&.name, + transaction.tags.pluck(:name).join(","), + transaction.entry.notes, + transaction.entry.currency + ] + end + end + end + + def generate_trades_csv + CSV.generate do |csv| + csv << [ "date", "account_name", "ticker", "quantity", "price", "amount", "currency" ] + + # Only export trades from accounts belonging to this family + @family.trades + .includes(:security, entry: :account) + .find_each do |trade| + csv << [ + trade.entry.date.iso8601, + trade.entry.account.name, + trade.security.ticker, + trade.qty.to_s, + trade.price.to_s, + trade.entry.amount.to_s, + trade.currency + ] + end + end + end + + def generate_categories_csv + CSV.generate do |csv| + csv << [ "name", "color", "parent_category", "classification" ] + + # Only export categories belonging to this family + @family.categories.includes(:parent).find_each do |category| + csv << [ + category.name, + category.color, + category.parent&.name, + category.classification + ] + end + end + end + + def generate_ndjson + lines = [] + + # Export accounts with full accountable data + @family.accounts.includes(:accountable).find_each do |account| + lines << { + type: "Account", + data: account.as_json( + include: { + accountable: {} + } + ) + }.to_json + end + + # Export categories + @family.categories.find_each do |category| + lines << { + type: "Category", + data: category.as_json + }.to_json + end + + # Export tags + @family.tags.find_each do |tag| + lines << { + type: "Tag", + data: tag.as_json + }.to_json + end + + # Export merchants (only family merchants) + @family.merchants.find_each do |merchant| + lines << { + type: "Merchant", + data: merchant.as_json + }.to_json + end + + # Export transactions with full data + @family.transactions.includes(:category, :merchant, :tags, entry: :account).find_each do |transaction| + lines << { + type: "Transaction", + data: { + id: transaction.id, + entry_id: transaction.entry.id, + account_id: transaction.entry.account_id, + date: transaction.entry.date, + amount: transaction.entry.amount, + currency: transaction.entry.currency, + name: transaction.entry.name, + notes: transaction.entry.notes, + excluded: transaction.entry.excluded, + category_id: transaction.category_id, + merchant_id: transaction.merchant_id, + tag_ids: transaction.tag_ids, + kind: transaction.kind, + created_at: transaction.created_at, + updated_at: transaction.updated_at + } + }.to_json + end + + # Export trades with full data + @family.trades.includes(:security, entry: :account).find_each do |trade| + lines << { + type: "Trade", + data: { + id: trade.id, + entry_id: trade.entry.id, + account_id: trade.entry.account_id, + security_id: trade.security_id, + ticker: trade.security.ticker, + date: trade.entry.date, + qty: trade.qty, + price: trade.price, + amount: trade.entry.amount, + currency: trade.currency, + created_at: trade.created_at, + updated_at: trade.updated_at + } + }.to_json + end + + # Export valuations + @family.entries.valuations.includes(:account, :entryable).find_each do |entry| + lines << { + type: "Valuation", + data: { + id: entry.entryable.id, + entry_id: entry.id, + account_id: entry.account_id, + date: entry.date, + amount: entry.amount, + currency: entry.currency, + name: entry.name, + created_at: entry.created_at, + updated_at: entry.updated_at + } + }.to_json + end + + # Export budgets + @family.budgets.find_each do |budget| + lines << { + type: "Budget", + data: budget.as_json + }.to_json + end + + # Export budget categories + @family.budget_categories.includes(:budget, :category).find_each do |budget_category| + lines << { + type: "BudgetCategory", + data: budget_category.as_json + }.to_json + end + + lines.join("\n") + end +end diff --git a/app/models/family_export.rb b/app/models/family_export.rb new file mode 100644 index 00000000000..292ab9e0a12 --- /dev/null +++ b/app/models/family_export.rb @@ -0,0 +1,22 @@ +class FamilyExport < ApplicationRecord + belongs_to :family + + has_one_attached :export_file + + enum :status, { + pending: "pending", + processing: "processing", + completed: "completed", + failed: "failed" + }, default: :pending, validate: true + + scope :ordered, -> { order(created_at: :desc) } + + def filename + "maybe_export_#{created_at.strftime('%Y%m%d_%H%M%S')}.zip" + end + + def downloadable? + completed? && export_file.attached? + end +end diff --git a/app/models/import.rb b/app/models/import.rb index b0a02ea0775..5d6bea64796 100644 --- a/app/models/import.rb +++ b/app/models/import.rb @@ -88,7 +88,7 @@ def revert entries.destroy_all end - family.sync + family.sync_later update! status: :pending rescue => error diff --git a/app/models/plaid_account/processor.rb b/app/models/plaid_account/processor.rb index 6c999911b8b..b42bdf3b6a7 100644 --- a/app/models/plaid_account/processor.rb +++ b/app/models/plaid_account/processor.rb @@ -51,6 +51,13 @@ def process_account! ) account.save! + + # Create or update the current balance anchor valuation for event-sourced ledger + # Note: This is a partial implementation. In the future, we'll introduce HoldingValuation + # to properly track the holdings vs. cash breakdown, but for now we're only tracking + # the total balance in the current anchor. The cash_balance field on the account model + # is still being used for the breakdown. + account.set_current_balance(balance_calculator.balance) end end diff --git a/app/models/transaction/search.rb b/app/models/transaction/search.rb index 2fc17182a89..ce38875400a 100644 --- a/app/models/transaction/search.rb +++ b/app/models/transaction/search.rb @@ -47,8 +47,8 @@ def totals Rails.cache.fetch("transaction_search_totals/#{cache_key_base}") do result = transactions_scope .select( - "COALESCE(SUM(CASE WHEN entries.amount >= 0 THEN ABS(entries.amount * COALESCE(er.rate, 1)) ELSE 0 END), 0) as expense_total", - "COALESCE(SUM(CASE WHEN entries.amount < 0 THEN ABS(entries.amount * COALESCE(er.rate, 1)) ELSE 0 END), 0) as income_total", + "COALESCE(SUM(CASE WHEN entries.amount >= 0 AND transactions.kind NOT IN ('funds_movement', 'cc_payment') THEN ABS(entries.amount * COALESCE(er.rate, 1)) ELSE 0 END), 0) as expense_total", + "COALESCE(SUM(CASE WHEN entries.amount < 0 AND transactions.kind NOT IN ('funds_movement', 'cc_payment') THEN ABS(entries.amount * COALESCE(er.rate, 1)) ELSE 0 END), 0) as income_total", "COUNT(entries.id) as transactions_count" ) .joins( @@ -61,8 +61,8 @@ def totals Totals.new( count: result.transactions_count.to_i, - income_money: Money.new(result.income_total.to_i, family.currency), - expense_money: Money.new(result.expense_total.to_i, family.currency) + income_money: Money.new(result.income_total.round, family.currency), + expense_money: Money.new(result.expense_total.round, family.currency) ) end end diff --git a/app/models/valuation.rb b/app/models/valuation.rb index fe3febcc2ba..f80226be31f 100644 --- a/app/models/valuation.rb +++ b/app/models/valuation.rb @@ -1,6 +1,12 @@ class Valuation < ApplicationRecord include Entryable + enum :kind, { + reconciliation: "reconciliation", + opening_anchor: "opening_anchor", + current_anchor: "current_anchor" + }, validate: true, default: "reconciliation" + class << self def build_reconciliation_name(accountable_type) Valuation::Name.new("reconciliation", accountable_type).to_s @@ -14,10 +20,4 @@ def build_current_anchor_name(accountable_type) Valuation::Name.new("current_anchor", accountable_type).to_s end end - - # TODO: Remove this method when `kind` column is added to valuations table - # This is a temporary implementation until the database migration is complete - def kind - "reconciliation" - end end diff --git a/app/models/valuation/name.rb b/app/models/valuation/name.rb index 6b442876183..79398cdeaaf 100644 --- a/app/models/valuation/name.rb +++ b/app/models/valuation/name.rb @@ -20,11 +20,11 @@ def to_s def opening_anchor_name case accountable_type - when "Property" + when "Property", "Vehicle" "Original purchase price" when "Loan" "Original principal" - when "Investment" + when "Investment", "Crypto", "OtherAsset" "Opening account value" else "Opening balance" @@ -33,11 +33,11 @@ def opening_anchor_name def current_anchor_name case accountable_type - when "Property" + when "Property", "Vehicle" "Current market value" when "Loan" "Current loan balance" - when "Investment" + when "Investment", "Crypto", "OtherAsset" "Current account value" else "Current balance" @@ -46,7 +46,7 @@ def current_anchor_name def recon_name case accountable_type - when "Property", "Investment" + when "Property", "Investment", "Vehicle", "Crypto", "OtherAsset" "Manual value update" when "Loan" "Manual principal update" diff --git a/app/services/api_rate_limiter.rb b/app/services/api_rate_limiter.rb index 9ceb9e799e1..d3a771cf5c9 100644 --- a/app/services/api_rate_limiter.rb +++ b/app/services/api_rate_limiter.rb @@ -67,7 +67,17 @@ def usage_info # Class method to get usage for an API key without incrementing def self.usage_for(api_key) - new(api_key).usage_info + limit(api_key).usage_info + end + + def self.limit(api_key) + if Rails.application.config.app_mode.self_hosted? + # Use NoopApiRateLimiter for self-hosted mode + # This means no rate limiting is applied + NoopApiRateLimiter.new(api_key) + else + new(api_key) + end end private diff --git a/app/services/noop_api_rate_limiter.rb b/app/services/noop_api_rate_limiter.rb new file mode 100644 index 00000000000..116b6537ed8 --- /dev/null +++ b/app/services/noop_api_rate_limiter.rb @@ -0,0 +1,39 @@ +class NoopApiRateLimiter + def initialize(api_key) + @api_key = api_key + end + + def rate_limit_exceeded? + false + end + + def increment_request_count! + # No operation + end + + def current_count + 0 + end + + def rate_limit + Float::INFINITY + end + + def reset_time + 0 + end + + def usage_info + { + current_count: 0, + rate_limit: Float::INFINITY, + remaining: Float::INFINITY, + reset_time: 0, + tier: :noop + } + end + + def self.usage_for(api_key) + new(api_key).usage_info + end +end diff --git a/app/views/accounts/_account.html.erb b/app/views/accounts/_account.html.erb index 9430d605df8..b1e1be99549 100644 --- a/app/views/accounts/_account.html.erb +++ b/app/views/accounts/_account.html.erb @@ -41,7 +41,7 @@ <% end %> <% if account.draft? %> - <%= render LinkComponent.new( + <%= render DS::Link.new( text: "Complete setup", href: edit_account_path(account, return_to: return_to), variant: :outline, @@ -49,7 +49,7 @@ ) %> <% elsif account.active? || account.disabled? %> <%= form_with model: account, url: toggle_active_account_path(account), method: :patch, data: { turbo_frame: "_top", controller: "auto-submit-form" } do |f| %> - <%= render ToggleComponent.new( + <%= render DS::Toggle.new( id: "account_#{account.id}_active", name: "active", checked: account.active?, diff --git a/app/views/accounts/_account_sidebar_tabs.html.erb b/app/views/accounts/_account_sidebar_tabs.html.erb index 182bdd6eb9e..8951cc3cdf9 100644 --- a/app/views/accounts/_account_sidebar_tabs.html.erb +++ b/app/views/accounts/_account_sidebar_tabs.html.erb @@ -21,7 +21,7 @@ <% end %> - <%= render TabsComponent.new(active_tab: active_tab, session_key: "account_sidebar_tab", testid: "account-sidebar-tabs") do |tabs| %> + <%= render DS::Tabs.new(active_tab: active_tab, session_key: "account_sidebar_tab", testid: "account-sidebar-tabs") do |tabs| %> <% tabs.with_nav do |nav| %> <% nav.with_btn(id: "asset", label: "Assets") %> <% nav.with_btn(id: "liability", label: "Debts") %> @@ -30,7 +30,7 @@ <% tabs.with_panel(tab_id: "asset") do %>