feat: add spent sum per envelope per month (#102)

Resolves #39.

Author: morremeyer

internal/controllers/all.go

@@ -0,0 +1,10 @@
+package controllers
+
+import "time"
+
+// This file holds types that are used over multiple files.
+
+// Month is used to parse requests for data about a specific month.
+type Month struct {
+	Month time.Time `form:"month" time_format:"2006-01" time_utc:"1"`
+}

internal/controllers/envelope.go

@@ -20,7 +20,7 @@ func RegisterEnvelopeRoutes(r *gin.RouterGroup) {
 		r.POST("", CreateEnvelope)
 	}
 
-	// Transaction with ID
+	// Envelope with ID
 	{
 		r.OPTIONS("/:envelopeId", func(c *gin.Context) {
 			c.Header("allow", "GET, PATCH, DELETE")
@@ -72,9 +72,37 @@ func GetEnvelope(c *gin.Context) {
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{"data": envelope, "links": map[string]string{
-		"allocations": requestURL(c) + "/allocations",
-	}})
+	// Parse the month from the request
+	var month Month
+	if err := c.ShouldBind(&month); err != nil {
+		FetchErrorHandler(c, err)
+		return
+	}
+
+	// If a month is requested, return only month specfic data
+	if !month.Month.IsZero() {
+		spent, err := envelope.Spent(month.Month)
+		if err != nil {
+			FetchErrorHandler(c, err)
+			return
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"data": map[string]interface{}{
+				"spent": spent,
+				"month": month.Month,
+			},
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"data": envelope,
+		"links": map[string]string{
+			"allocations": requestURL(c) + "/allocations",
+			"month":       requestURL(c) + "?month=YYYY-MM",
+		},
+	})
 }
 
 // UpdateEnvelope updates a envelope, selected by the ID parameter.

internal/controllers/envelope_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/envelope-zero/backend/internal/models"
 	"github.com/envelope-zero/backend/internal/test"
+	"github.com/shopspring/decimal"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -21,6 +22,14 @@ type EnvelopeDetailResponse struct {
 	Data models.Envelope
 }
 
+type EnvelopeMonthResponse struct {
+	test.APIResponse
+	Data struct {
+		Month time.Time       `json:"month"`
+		Spent decimal.Decimal `json:"spent"`
+	}
+}
+
 func TestGetEnvelopes(t *testing.T) {
 	recorder := test.Request(t, "GET", "/v1/budgets/1/categories/1/envelopes", "")
 
@@ -132,6 +141,32 @@ func TestGetEnvelope(t *testing.T) {
 	assert.Equal(t, dbEnvelope, envelope.Data)
 }
 
+func TestEnvelopeMonth(t *testing.T) {
+	var envelopeMonth EnvelopeMonthResponse
+
+	r := test.Request(t, "GET", "/v1/budgets/1/categories/1/envelopes/1?month=2022-01", "")
+	test.AssertHTTPStatus(t, http.StatusOK, &r)
+	spent := decimal.NewFromFloat(-10)
+	test.DecodeResponse(t, &r, &envelopeMonth)
+	assert.True(t, envelopeMonth.Data.Spent.Equal(spent), "Month calculation for 2022-01 is wrong: should be %v, but is %v", spent, envelopeMonth.Data.Spent)
+
+	r = test.Request(t, "GET", "/v1/budgets/1/categories/1/envelopes/1?month=2022-02", "")
+	test.AssertHTTPStatus(t, http.StatusOK, &r)
+	spent = decimal.NewFromFloat(-5)
+	test.DecodeResponse(t, &r, &envelopeMonth)
+	assert.True(t, envelopeMonth.Data.Spent.Equal(spent), "Month calculation for 2022-02 is wrong: should be %v, but is %v", spent, envelopeMonth.Data.Spent)
+
+	r = test.Request(t, "GET", "/v1/budgets/1/categories/1/envelopes/1?month=2022-03", "")
+	test.AssertHTTPStatus(t, http.StatusOK, &r)
+	spent = decimal.NewFromFloat(-15)
+	test.DecodeResponse(t, &r, &envelopeMonth)
+	assert.True(t, envelopeMonth.Data.Spent.Equal(spent), "Month calculation for 2022-03 is wrong: should be %v, but is %v", spent, envelopeMonth.Data.Spent)
+
+	// Test that non-parseable requests produce an error
+	r = test.Request(t, "GET", "/v1/budgets/1/categories/1/envelopes/1?month=Stonks!", "")
+	test.AssertHTTPStatus(t, http.StatusBadRequest, &r)
+}
+
 func TestUpdateEnvelope(t *testing.T) {
 	recorder := test.Request(t, "POST", "/v1/budgets/1/categories/1/envelopes", `{ "name": "New Envelope", "note": "More tests something something" }`)
 	test.AssertHTTPStatus(t, http.StatusCreated, &recorder)

internal/controllers/helper.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"reflect"
 	"strconv"
+	"time"
 
 	"github.com/envelope-zero/backend/internal/models"
 	"github.com/gin-contrib/requestid"
@@ -231,6 +232,8 @@ func FetchErrorHandler(c *gin.Context, err error) {
 		c.JSON(http.StatusBadRequest, gin.H{
 			"error": "An ID specified in the query string was not a valid uint64",
 		})
+	} else if reflect.TypeOf(err) == reflect.TypeOf(&time.ParseError{}) {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 	} else {
 		log.Error().Str("request-id", requestid.Get(c)).Msgf("%T: %v", err, err.Error())
 		c.JSON(http.StatusInternalServerError, gin.H{

internal/models/account.go

@@ -1,8 +1,6 @@
 package models
 
 import (
-	"fmt"
-
 	"github.com/shopspring/decimal"
 	"gorm.io/gorm"
 )
@@ -48,69 +46,28 @@ func (a Account) Transactions() []Transaction {
 	var transactions []Transaction
 
 	// Get all transactions where the account is either the source or the destination
-	DB.Where(
-		"source_account_id = ?", a.ID,
-	).Or("destination_account_id = ?", a.ID).Find(&transactions)
-
+	DB.Where(Transaction{SourceAccountID: a.ID}).Or(Transaction{DestinationAccountID: a.ID}).Find(&transactions)
 	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{
+	return TransactionsSum(
+		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
+		},
+		Transaction{
+			Reconciled:      true,
+			SourceAccountID: a.ID,
+		},
+	)
 }
 
 // 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(&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(&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)
-	}
-
-	return destinationSum.Decimal.Sub(sourceSum.Decimal), nil
+	return TransactionsSum(
+		Transaction{DestinationAccountID: a.ID},
+		Transaction{SourceAccountID: a.ID},
+	)
 }

internal/models/all.go

@@ -0,0 +1,41 @@
+package models
+
+import (
+	"fmt"
+
+	"github.com/shopspring/decimal"
+)
+
+// TransactionSums returns the sum of all transactions matching two Transaction structs
+//
+// The incoming Transactions fields is used to add the amount of all matching transactions to the overall sum
+// The outgoing Transactions fields is used to subtract the amount of all matching transactions from the overall sum.
+func TransactionsSum(incoming, outgoing Transaction) (decimal.Decimal, error) {
+	var outgoingSum, incomingSum decimal.NullDecimal
+
+	_ = DB.Table("transactions").
+		Where(&outgoing).
+		Select("SUM(amount)").
+		Row().
+		Scan(&outgoingSum)
+
+	_ = DB.Table("transactions").
+		Where(&incoming).
+		Select("SUM(amount)").
+		Row().
+		Scan(&incomingSum)
+
+	return incomingSum.Decimal.Sub(outgoingSum.Decimal), nil
+}
+
+// RawTransactions returns a list of transactions for a raw SQL query.
+func RawTransactions(query string) ([]Transaction, error) {
+	var transactions []Transaction
+
+	err := DB.Raw(query).Scan(&transactions).Error
+	if err != nil {
+		return []Transaction{}, fmt.Errorf("getting transactions with query '%v' failed: %w", query, err)
+	}
+
+	return transactions, nil
+}

internal/models/all_test.go

@@ -0,0 +1,14 @@
+package models_test
+
+import (
+	"testing"
+
+	"github.com/envelope-zero/backend/internal/models"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRawTransactions(t *testing.T) {
+	_, err := models.RawTransactions("INVALID query string")
+
+	assert.NotNil(t, err)
+}

internal/models/envelope.go

@@ -1,5 +1,12 @@
 package models
 
+import (
+	"fmt"
+	"time"
+
+	"github.com/shopspring/decimal"
+)
+
 // Envelope represents an envelope in your budget.
 type Envelope struct {
 	Model
@@ -8,3 +15,34 @@ type Envelope struct {
 	Category   Category `json:"-"`
 	Note       string   `json:"note,omitempty"`
 }
+
+// Spent returns the amount spent for the month the time.Time instance is in.
+func (e Envelope) Spent(t time.Time) (decimal.Decimal, error) {
+	// All transactions where the Envelope ID matches and that have an external account as source and an internal account as destination
+	incoming, _ := RawTransactions(
+		fmt.Sprintf("SELECT transactions.* FROM transactions, accounts AS source_accounts, accounts AS destination_accounts WHERE transactions.source_account_id = source_accounts.id AND source_accounts.external AND transactions.destination_account_id = destination_accounts.id AND NOT destination_accounts.external AND transactions.envelope_id = %v", e.ID),
+	)
+
+	// Add all incoming transactions that are in the correct month
+	incomingSum := decimal.Zero
+	for _, transaction := range incoming {
+		if transaction.Date.UTC().Year() == t.UTC().Year() && transaction.Date.UTC().Month() == t.UTC().Month() {
+			incomingSum = incomingSum.Add(transaction.Amount)
+		}
+	}
+
+	outgoing, _ := RawTransactions(
+		// All transactions where the envelope ID matches that have an internal account as source and an external account as destination
+		fmt.Sprintf("SELECT transactions.* FROM transactions, accounts AS source_accounts, accounts AS destination_accounts WHERE transactions.source_account_id = source_accounts.id AND NOT source_accounts.external AND transactions.destination_account_id = destination_accounts.id AND destination_accounts.external AND transactions.envelope_id = %v", e.ID),
+	)
+
+	// Add all outgoing transactions that are in the correct month
+	outgoingSum := decimal.Zero
+	for _, transaction := range outgoing {
+		if transaction.Date.UTC().Year() == t.UTC().Year() && transaction.Date.UTC().Month() == t.UTC().Month() {
+			outgoingSum = outgoingSum.Add(transaction.Amount)
+		}
+	}
+
+	return incomingSum.Sub(outgoingSum), nil
+}

internal/models/envelope_test.go

@@ -0,0 +1,55 @@
+package models_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/envelope-zero/backend/internal/models"
+	"github.com/shopspring/decimal"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEnvelopeMonthSum(t *testing.T) {
+	internalAccount := &models.Account{
+		Name: "Internal Source Account",
+	}
+	models.DB.Create(internalAccount)
+
+	externalAccount := &models.Account{
+		Name:     "External Destination Account",
+		External: true,
+	}
+	models.DB.Create(&externalAccount)
+
+	envelope := &models.Envelope{
+		Name: "Testing envelope",
+	}
+	models.DB.Create(&envelope)
+
+	spent := decimal.NewFromFloat(17.32)
+	transaction := &models.Transaction{
+		EnvelopeID:           envelope.ID,
+		Amount:               spent,
+		SourceAccountID:      internalAccount.ID,
+		DestinationAccountID: externalAccount.ID,
+		Date:                 time.Date(2022, 1, 15, 0, 0, 0, 0, time.UTC),
+	}
+	models.DB.Create(&transaction)
+
+	transactionIn := &models.Transaction{
+		EnvelopeID:           envelope.ID,
+		Amount:               spent.Neg(),
+		SourceAccountID:      externalAccount.ID,
+		DestinationAccountID: internalAccount.ID,
+		Date:                 time.Date(2022, 2, 15, 0, 0, 0, 0, time.UTC),
+	}
+	models.DB.Create(&transactionIn)
+
+	envelopeSpent, err := envelope.Spent(time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC))
+	assert.Nil(t, err)
+	assert.True(t, envelopeSpent.Equal(spent.Neg()), "Month calculation for 2022-01 is wrong: should be %v, but is %v", spent.Neg(), envelopeSpent)
+
+	envelopeSpent, err = envelope.Spent(time.Date(2022, 2, 1, 0, 0, 0, 0, time.UTC))
+	assert.Nil(t, err)
+	assert.True(t, envelopeSpent.Equal(spent.Neg()), "Month calculation for 2022-02 is wrong: should be %v, but is %v", spent, envelopeSpent)
+}