Rework account views and addition flow (#1324)

* Move accountable partials

* Split accountables into separate view partials

* Fix test

* Add form to permitted partials

* Fix failing system tests

* Update new account modal views

* New sync algorithm implementation

* Update account system test assertions to match new behavior

* Fix off by 1 date error

* Revert new balance sync algorithm

* Add missing account overviews

app/models/account.rb

@@ -27,6 +27,8 @@ class Account < ApplicationRecord
   scope :alphabetically, -> { order(:name) }
   scope :ungrouped, -> { where(institution_id: nil) }
 
+  has_one_attached :logo
+
   delegated_type :accountable, types: Accountable::TYPES, dependent: :destroy
 
   accepts_nested_attributes_for :accountable

app/models/account/balance/calculator.rb

@@ -0,0 +1,57 @@
+class Account::Balance::Calculator
+  def initialize(account, sync_start_date)
+    @account = account
+    @sync_start_date = sync_start_date
+  end
+
+  def calculate(is_partial_sync: false)
+    cached_entries = account.entries.where("date >= ?", sync_start_date).to_a
+    sync_starting_balance = is_partial_sync ? find_start_balance_for_partial_sync : find_start_balance_for_full_sync(cached_entries)
+
+    prior_balance = sync_starting_balance
+
+    (sync_start_date..Date.current).map do |date|
+      current_balance = calculate_balance_for_date(date, entries: cached_entries, prior_balance:)
+
+      prior_balance = current_balance
+
+      build_balance(date, current_balance)
+    end
+  end
+
+  private
+    attr_reader :account, :sync_start_date
+
+    def find_start_balance_for_partial_sync
+      account.balances.find_by(currency: account.currency, date: sync_start_date - 1.day).balance
+    end
+
+    def find_start_balance_for_full_sync(cached_entries)
+      account.balance + net_entry_flows(cached_entries)
+    end
+
+    def calculate_balance_for_date(date, entries:, prior_balance:)
+      valuation = entries.find { |e| e.date == date && e.account_valuation? }
+
+      return valuation.amount if valuation
+
+      entries = entries.select { |e| e.date == date }
+
+      prior_balance - net_entry_flows(entries)
+    end
+
+    def net_entry_flows(entries, target_currency = account.currency)
+      converted_entry_amounts = entries.map { |t| t.amount_money.exchange_to(target_currency, date: t.date) }
+
+      flows = converted_entry_amounts.sum(&:amount)
+
+      account.liability? ? flows * -1 : flows
+    end
+
+    def build_balance(date, balance, currency = nil)
+      account.balances.build \
+        date: date,
+        balance: balance,
+        currency: currency || account.currency
+    end
+end

app/models/account/balance/converter.rb

@@ -0,0 +1,46 @@
+class Account::Balance::Converter
+  def initialize(account, sync_start_date)
+    @account = account
+    @sync_start_date = sync_start_date
+  end
+
+  def convert(balances)
+    calculate_converted_balances(balances)
+  end
+
+  private
+    attr_reader :account, :sync_start_date
+
+    def calculate_converted_balances(balances)
+      from_currency = account.currency
+      to_currency = account.family.currency
+
+      if ExchangeRate.exchange_rates_provider.nil?
+        account.observe_missing_exchange_rate_provider
+        return []
+      end
+
+      exchange_rates = ExchangeRate.find_rates from: from_currency,
+                                               to: to_currency,
+                                               start_date: sync_start_date
+
+      missing_exchange_rates = balances.map(&:date) - exchange_rates.map(&:date)
+
+      if missing_exchange_rates.any?
+        account.observe_missing_exchange_rates(from: from_currency, to: to_currency, dates: missing_exchange_rates)
+        return []
+      end
+
+      balances.map do |balance|
+        exchange_rate = exchange_rates.find { |er| er.date == balance.date }
+        build_balance(balance.date, exchange_rate.rate * balance.balance, to_currency)
+      end
+    end
+
+    def build_balance(date, balance, currency = nil)
+      account.balances.build \
+        date: date,
+        balance: balance,
+        currency: currency || account.currency
+    end
+end

app/models/account/balance/loader.rb

@@ -0,0 +1,37 @@
+class Account::Balance::Loader
+  def initialize(account)
+    @account = account
+  end
+
+  def load(balances, start_date)
+    Account::Balance.transaction do
+      upsert_balances!(balances)
+      purge_stale_balances!(start_date)
+
+      account.reload
+
+      update_account_balance!(balances)
+    end
+  end
+
+  private
+    attr_reader :account
+
+    def update_account_balance!(balances)
+      last_balance = balances.select { |db| db.currency == account.currency }.last&.balance
+      account.update! balance: last_balance if last_balance.present?
+    end
+
+    def upsert_balances!(balances)
+      current_time = Time.now
+      balances_to_upsert = balances.map do |balance|
+        balance.attributes.slice("date", "balance", "currency").merge("updated_at" => current_time)
+      end
+
+      account.balances.upsert_all(balances_to_upsert, unique_by: %i[account_id date currency])
+    end
+
+    def purge_stale_balances!(start_date)
+      account.balances.delete_by("date < ?", start_date)
+    end
+end

app/models/account/balance/syncer.rb

@@ -1,133 +1,51 @@
 class Account::Balance::Syncer
   def initialize(account, start_date: nil)
     @account = account
+    @provided_start_date = start_date
     @sync_start_date = calculate_sync_start_date(start_date)
+    @loader = Account::Balance::Loader.new(account)
+    @converter = Account::Balance::Converter.new(account, sync_start_date)
+    @calculator = Account::Balance::Calculator.new(account, sync_start_date)
   end
 
   def run
-    daily_balances = calculate_daily_balances
-    daily_balances += calculate_converted_balances(daily_balances) if account.currency != account.family.currency
+    daily_balances = calculator.calculate(is_partial_sync: is_partial_sync?)
+    daily_balances += converter.convert(daily_balances) if account.currency != account.family.currency
 
-    Account::Balance.transaction do
-      upsert_balances!(daily_balances)
-      purge_stale_balances!
-
-      if daily_balances.any?
-        account.reload
-        last_balance = daily_balances.select { |db| db.currency == account.currency }.last&.balance
-        account.update! balance: last_balance
-      end
-    end
+    loader.load(daily_balances, account_start_date)
   rescue Money::ConversionError => e
     account.observe_missing_exchange_rates(from: e.from_currency, to: e.to_currency, dates: [ e.date ])
   end
 
   private
 
-    attr_reader :sync_start_date, :account
-
-    def upsert_balances!(balances)
-      current_time = Time.now
-      balances_to_upsert = balances.map do |balance|
-        balance.attributes.slice("date", "balance", "currency").merge("updated_at" => current_time)
-      end
-
-      account.balances.upsert_all(balances_to_upsert, unique_by: %i[account_id date currency])
-    end
-
-    def purge_stale_balances!
-      account.balances.delete_by("date < ?", account_start_date)
-    end
-
-    def calculate_balance_for_date(date, entries:, prior_balance:)
-      valuation = entries.find { |e| e.date == date && e.account_valuation? }
-
-      return valuation.amount if valuation
-      return derived_sync_start_balance(entries) unless prior_balance
-
-      entries = entries.select { |e| e.date == date }
-
-      prior_balance - net_entry_flows(entries)
-    end
-
-    def calculate_daily_balances
-      entries = account.entries.where("date >= ?", sync_start_date).to_a
-      prior_balance = find_prior_balance
-
-      (sync_start_date..Date.current).map do |date|
-        current_balance = calculate_balance_for_date(date, entries:, prior_balance:)
-
-        prior_balance = current_balance
-
-        build_balance(date, current_balance)
-      end
-    end
-
-    def calculate_converted_balances(balances)
-      from_currency = account.currency
-      to_currency = account.family.currency
-
-      if ExchangeRate.exchange_rates_provider.nil?
-        account.observe_missing_exchange_rate_provider
-        return []
-      end
-
-      exchange_rates = ExchangeRate.find_rates from: from_currency,
-                                               to: to_currency,
-                                               start_date: sync_start_date
-
-      missing_exchange_rates = balances.map(&:date) - exchange_rates.map(&:date)
-
-      if missing_exchange_rates.any?
-        account.observe_missing_exchange_rates(from: from_currency, to: to_currency, dates: missing_exchange_rates)
-        return []
-      end
-
-      balances.map do |balance|
-        exchange_rate = exchange_rates.find { |er| er.date == balance.date }
-        build_balance(balance.date, exchange_rate.rate * balance.balance, to_currency)
-      end
-    end
-
-    def build_balance(date, balance, currency = nil)
-      account.balances.build \
-        date: date,
-        balance: balance,
-        currency: currency || account.currency
-    end
-
-    def derived_sync_start_balance(entries)
-      transactions_and_trades = entries.reject { |e| e.account_valuation? }.select { |e| e.date > sync_start_date }
-
-      account.balance + net_entry_flows(transactions_and_trades)
-    end
-
-    def find_prior_balance
-      account.balances.where(currency: account.currency).where("date < ?", sync_start_date).order(date: :desc).first&.balance
-    end
-
-    def net_entry_flows(entries, target_currency = account.currency)
-      converted_entry_amounts = entries.map { |t| t.amount_money.exchange_to(target_currency, date: t.date) }
-
-      flows = converted_entry_amounts.sum(&:amount)
-
-      account.liability? ? flows * -1 : flows
-    end
+    attr_reader :sync_start_date, :provided_start_date, :account, :loader, :converter, :calculator
 
     def account_start_date
       @account_start_date ||= begin
-                                oldest_entry_date = account.entries.chronological.first.try(:date)
+                                oldest_entry = account.entries.chronological.first
 
-                                return Date.current unless oldest_entry_date
+                                return Date.current unless oldest_entry.present?
 
-                                oldest_entry_is_valuation = account.entries.account_valuations.where(date: oldest_entry_date).exists?
-
-                                oldest_entry_date -= 1 unless oldest_entry_is_valuation
-                                oldest_entry_date
+                                if oldest_entry.account_valuation?
+                                  oldest_entry.date
+                                else
+                                  oldest_entry.date - 1.day
+                                end
                               end
     end
 
     def calculate_sync_start_date(provided_start_date)
-      [ provided_start_date, account_start_date ].compact.max
+      return provided_start_date if provided_start_date.present? && prior_balance_available?(provided_start_date)
+
+      account_start_date
+    end
+
+    def prior_balance_available?(date)
+      account.balances.find_by(currency: account.currency, date: date - 1.day).present?
+    end
+
+    def is_partial_sync?
+      sync_start_date == provided_start_date && sync_start_date < Date.current
     end
 end

app/models/credit_card.rb

@@ -12,4 +12,8 @@ class CreditCard < ApplicationRecord
   def annual_fee_money
     annual_fee ? Money.new(annual_fee, account.currency) : nil
   end
+
+  def color
+    "#F13636"
+  end
 end

app/models/crypto.rb

@@ -1,3 +1,7 @@
 class Crypto < ApplicationRecord
   include Accountable
+
+  def color
+    "#737373"
+  end
 end

app/models/depository.rb

@@ -1,3 +1,7 @@
 class Depository < ApplicationRecord
   include Accountable
+
+  def color
+    "#875BF7"
+  end
 end

app/models/investment.rb

@@ -46,4 +46,8 @@ class Investment < ApplicationRecord
   rescue Money::ConversionError
     TimeSeries.new([])
   end
+
+  def color
+    "#1570EF"
+  end
 end

app/models/loan.rb

@@ -16,4 +16,8 @@ class Loan < ApplicationRecord
 
     Money.new(payment.round, account.currency)
   end
+
+  def color
+    "#D444F1"
+  end
 end

app/models/other_asset.rb

@@ -1,3 +1,7 @@
 class OtherAsset < ApplicationRecord
   include Accountable
+
+  def color
+    "#12B76A"
+  end
 end

app/models/other_liability.rb

@@ -1,3 +1,7 @@
 class OtherLiability < ApplicationRecord
   include Accountable
+
+  def color
+    "#737373"
+  end
 end

app/models/property.rb

@@ -19,6 +19,10 @@ class Property < ApplicationRecord
     TimeSeries::Trend.new(current: account.balance_money, previous: first_valuation_amount)
   end
 
+  def color
+    "#06AED4"
+  end
+
   private
     def first_valuation_amount
       account.entries.account_valuations.order(:date).first&.amount_money || account.balance_money

app/models/vehicle.rb

@@ -15,6 +15,10 @@ class Vehicle < ApplicationRecord
     TimeSeries::Trend.new(current: account.balance_money, previous: first_valuation_amount)
   end
 
+  def color
+    "#F23E94"
+  end
+
   private
     def first_valuation_amount
       account.entries.account_valuations.order(:date).first&.amount_money || account.balance_money