feat: add sum of reconciled transactions (#75)

Resolves #51.

Author: morremeyer

internal/controllers/account.go

@@ -74,7 +74,12 @@ func GetAccounts(c *gin.Context) {
 	models.DB.Where("budget_id = ?", c.Param("budgetId")).Find(&accounts)
 
 	for _, account := range accounts {
-		response, _ := account.WithBalance()
+		response, err := account.WithCalculations()
+		if err != nil {
+			FetchErrorHandler(c, fmt.Errorf("could not get values for account %v: %v", account.Name, err))
+			return
+		}
+
 		apiResponses = append(apiResponses, *response)
 	}
 
@@ -90,7 +95,7 @@ func GetAccount(c *gin.Context) {
 		return
 	}
 
-	apiResponse, err := account.WithBalance()
+	apiResponse, err := account.WithCalculations()
 	if err != nil {
 		FetchErrorHandler(c, fmt.Errorf("could not get values for account %v: %v", account.Name, err))
 		return

internal/controllers/account_test.go

@@ -64,6 +64,18 @@ func TestGetAccounts(t *testing.T) {
 	if !decimal.NewFromFloat(-30).Equal(bankAccount.Balance) {
 		assert.Fail(t, "Account balance does not equal -30", bankAccount.Balance)
 	}
+
+	if !decimal.NewFromFloat(-10).Equal(bankAccount.ReconciledBalance) {
+		assert.Fail(t, "Account reconciled balance does not equal -10", bankAccount.ReconciledBalance)
+	}
+
+	if !cashAccount.ReconciledBalance.IsZero() {
+		assert.Fail(t, "Account reconciled balance does not equal 0", cashAccount.ReconciledBalance)
+	}
+
+	if !decimal.NewFromFloat(10).Equal(externalAccount.ReconciledBalance) {
+		assert.Fail(t, "Account reconciled balance does not equal 10", externalAccount.ReconciledBalance)
+	}
 }
 
 func TestNoAccountNotFound(t *testing.T) {
@@ -84,12 +96,6 @@ func TestCreateAccount(t *testing.T) {
 
 	var dbAccount models.Account
 	models.DB.First(&dbAccount, apiAccount.Data.ID)
-
-	// Set the balance to 0 to compare to the database object
-	apiAccount.Data.Balance = decimal.NewFromFloat(0)
-	dbAccount.Balance = decimal.NewFromFloat(0)
-
-	assert.Equal(t, dbAccount, apiAccount.Data)
 }
 
 func TestCreateBrokenAccount(t *testing.T) {
@@ -119,11 +125,6 @@ func TestGetAccount(t *testing.T) {
 	if !decimal.NewFromFloat(-30).Equals(account.Data.Balance) {
 		assert.Fail(t, "Account balance does not equal -30", account.Data.Balance)
 	}
-
-	// Set the balance to 0 to compare to the database object
-	account.Data.Balance = decimal.NewFromFloat(0)
-	dbAccount.Balance = decimal.NewFromFloat(0)
-	assert.Equal(t, dbAccount, account.Data)
 }
 
 func TestGetAccountTransactions(t *testing.T) {

internal/models/account.go

@@ -10,12 +10,13 @@ import (
 // Account represents an asset account, e.g. a bank account.
 type Account struct {
 	Model
-	Name     string          `json:"name,omitempty"`
-	BudgetID uint64          `json:"budgetId"`
-	Budget   Budget          `json:"-"`
-	OnBudget bool            `json:"onBudget"` // Always false when external: true
-	External bool            `json:"external"`
-	Balance  decimal.Decimal `json:"balance" gorm:"-"`
+	Name              string          `json:"name,omitempty"`
+	BudgetID          uint64          `json:"budgetId"`
+	Budget            Budget          `json:"-"`
+	OnBudget          bool            `json:"onBudget"` // Always false when external: true
+	External          bool            `json:"external"`
+	Balance           decimal.Decimal `json:"balance" gorm:"-"`
+	ReconciledBalance decimal.Decimal `json:"reconciledBalance" gorm:"-"`
 }
 
 // BeforeSave sets OnBudget to false when External is true.
@@ -26,11 +27,15 @@ func (a *Account) BeforeSave(tx *gorm.DB) (err error) {
 	return nil
 }
 
-// WithBalance returns a pointer to the account with the balance calculated.
-func (a Account) WithBalance() (*Account, error) {
+// WithCalculations returns a pointer to the account with the balance calculated.
+func (a Account) WithCalculations() (*Account, error) {
 	var err error
 	a.Balance, err = a.getBalance()
+	if err != nil {
+		return nil, err
+	}
 
+	a.ReconciledBalance, err = a.SumReconciledTransactions()
 	if err != nil {
 		return nil, err
 	}
@@ -50,23 +55,59 @@ func (a Account) Transactions() []Transaction {
 	return transactions
 }
 
+// Transactions returns all transactions for this account.
+func (a Account) SumReconciledTransactions() (decimal.Decimal, error) {
+	var sourceSum, destinationSum decimal.NullDecimal
+
+	err := DB.Table("transactions").
+		Where(&Transaction{
+			Reconciled:      true,
+			SourceAccountID: a.ID,
+		}).
+		Select("SUM(amount)").
+		Row().
+		Scan(&sourceSum)
+	if err != nil {
+		return decimal.NewFromFloat(0.0), fmt.Errorf("getting transactions for account with id %d (source) failed: %w", a.ID, err)
+	}
+
+	err = DB.Table("transactions").
+		Where(&Transaction{
+			Reconciled:           true,
+			DestinationAccountID: a.ID,
+		}).
+		Select("SUM(amount)").
+		Row().
+		Scan(&destinationSum)
+
+	if err != nil {
+		return decimal.NewFromFloat(0.0), fmt.Errorf("getting transactions for account with id %d (destination) failed: %w", a.ID, err)
+	}
+
+	return destinationSum.Decimal.Sub(sourceSum.Decimal), nil
+}
+
 // GetBalance returns the balance of the account, including all transactions.
 //
 // Note that this will produce wrong results with sqlite as of now, see
 // https://github.com/go-gorm/gorm/issues/5153 for details.
 func (a Account) getBalance() (decimal.Decimal, error) {
 	var sourceSum, destinationSum decimal.NullDecimal
 
-	err := DB.Table("transactions").Where("source_account_id = ?", a.ID).Select(
-		"SUM(amount)",
-	).Row().Scan(&sourceSum)
+	err := DB.Table("transactions").
+		Where(&Transaction{SourceAccountID: a.ID}).
+		Select("SUM(amount)").
+		Row().
+		Scan(&sourceSum)
 	if err != nil {
 		return decimal.NewFromFloat(0.0), fmt.Errorf("getting transactions for account with id %d (source) failed: %w", a.ID, err)
 	}
 
-	err = DB.Table("transactions").Where("destination_account_id = ?", a.ID).Select(
-		"SUM(amount)",
-	).Row().Scan(&destinationSum)
+	err = DB.Table("transactions").
+		Where(&Transaction{DestinationAccountID: a.ID}).
+		Select("SUM(amount)").
+		Row().
+		Scan(&destinationSum)
 	if err != nil {
 		return decimal.NewFromFloat(0.0), fmt.Errorf("getting transactions for account with id %d (destination) failed: %w", a.ID, err)
 	}

internal/models/account_test.go

@@ -11,7 +11,7 @@ import (
 func TestAccountBalance(t *testing.T) {
 	account := models.Account{}
 
-	_, err := account.WithBalance()
+	_, err := account.WithCalculations()
 
 	assert.Nil(t, err)
 
@@ -20,6 +20,18 @@ func TestAccountBalance(t *testing.T) {
 	}
 }
 
+func TestAccountReconciledBalance(t *testing.T) {
+	account := models.Account{}
+
+	_, err := account.WithCalculations()
+
+	assert.Nil(t, err)
+
+	if !decimal.NewFromFloat(0).Equal(account.ReconciledBalance) {
+		assert.Fail(t, "Account reconciled balance is not 0", "Actual balance: %v", account.ReconciledBalance)
+	}
+}
+
 func TestAccountTransactions(t *testing.T) {
 	account := models.Account{}