feat: extract into remaining packages

There has been a cyclic dependency. transaction -> treasure_chest -> transaction_recurring -> transaction This has been temporarily solved by moving the GenerateTransactions function into the transaction package. In the future, this function has to be rewritten to use a proper Service insteas of direct DB access or replaced with a different system entirely.
2025-12-31 22:24:21 +01:00
parent 6de8d8fb10
commit 1be46780bb
29 changed files with 230 additions and 251 deletions
--- a/internal/transaction/handler.go
+++ b/internal/transaction/handler.go
@@ -0,0 +1,301 @@
+package transaction
+
+import (
+	"fmt"
+	"math"
+	"net/http"
+	"spend-sparrow/internal/account"
+	"spend-sparrow/internal/core"
+	"spend-sparrow/internal/treasure_chest"
+	"spend-sparrow/internal/treasure_chest_types"
+	"strconv"
+	"time"
+
+	"github.com/a-h/templ"
+	"github.com/google/uuid"
+)
+
+const (
+	DECIMALS_MULTIPLIER = 100
+)
+
+type Handler interface {
+	Handle(router *http.ServeMux)
+}
+
+type HandlerImpl struct {
+	s             Service
+	account       account.Service
+	treasureChest treasure_chest.Service
+	r             *core.Render
+}
+
+func NewHandler(s Service, account account.Service, treasureChest treasure_chest.Service, r *core.Render) Handler {
+	return HandlerImpl{
+		s:             s,
+		account:       account,
+		treasureChest: treasureChest,
+		r:             r,
+	}
+}
+
+func (h HandlerImpl) Handle(r *http.ServeMux) {
+	r.Handle("GET /transaction", h.handleTransactionPage())
+	r.Handle("GET /transaction/{id}", h.handleTransactionItemComp())
+	r.Handle("POST /transaction/{id}", h.handleUpdateTransaction())
+	r.Handle("POST /transaction/recalculate", h.handleRecalculate())
+	r.Handle("DELETE /transaction/{id}", h.handleDeleteTransaction())
+}
+
+func (h HandlerImpl) handleTransactionPage() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		core.UpdateSpan(r)
+
+		user := core.GetUser(r)
+		if user == nil {
+			core.DoRedirect(w, r, "/auth/signin")
+			return
+		}
+
+		filter := TransactionItemsFilter{
+			AccountId:       r.URL.Query().Get("account-id"),
+			TreasureChestId: r.URL.Query().Get("treasure-chest-id"),
+			Error:           r.URL.Query().Get("error"),
+			Page:            r.URL.Query().Get("page"),
+		}
+
+		transactions, err := h.s.GetAll(r.Context(), user, filter)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		accounts, err := h.account.GetAll(r.Context(), user)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		treasureChests, err := h.treasureChest.GetAll(r.Context(), user)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		accountMap, treasureChestMap := h.getTransactionData(accounts, treasureChests)
+
+		items := TransactionItems(transactions, accountMap, treasureChestMap)
+		if core.IsHtmx(r) {
+			h.r.Render(r, w, items)
+		} else {
+			comp := TransactionComp(items, filter, accounts, treasureChests)
+			h.r.RenderLayout(r, w, comp, user)
+		}
+	}
+}
+
+func (h HandlerImpl) handleTransactionItemComp() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		core.UpdateSpan(r)
+
+		user := core.GetUser(r)
+		if user == nil {
+			core.DoRedirect(w, r, "/auth/signin")
+			return
+		}
+
+		accounts, err := h.account.GetAll(r.Context(), user)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		treasureChests, err := h.treasureChest.GetAll(r.Context(), user)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		id := r.PathValue("id")
+		if id == "new" {
+			comp := EditTransaction(nil, accounts, treasureChests)
+			h.r.Render(r, w, comp)
+			return
+		}
+
+		transaction, err := h.s.Get(r.Context(), user, id)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		var comp templ.Component
+		if r.URL.Query().Get("edit") == "true" {
+			comp = EditTransaction(transaction, accounts, treasureChests)
+		} else {
+			accountMap, treasureChestMap := h.getTransactionData(accounts, treasureChests)
+			comp = TransactionItem(transaction, accountMap, treasureChestMap)
+		}
+		h.r.Render(r, w, comp)
+	}
+}
+
+func (h HandlerImpl) handleUpdateTransaction() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		core.UpdateSpan(r)
+
+		user := core.GetUser(r)
+		if user == nil {
+			core.DoRedirect(w, r, "/auth/signin")
+			return
+		}
+
+		var (
+			id  uuid.UUID
+			err error
+		)
+
+		idStr := r.PathValue("id")
+		if idStr != "new" {
+			id, err = uuid.Parse(idStr)
+			if err != nil {
+				core.HandleError(w, r, fmt.Errorf("could not parse Id: %w", core.ErrBadRequest))
+				return
+			}
+		}
+
+		accountIdStr := r.FormValue("account-id")
+		var accountId *uuid.UUID
+		if accountIdStr != "" {
+			i, err := uuid.Parse(accountIdStr)
+			if err != nil {
+				core.HandleError(w, r, fmt.Errorf("could not parse account id: %w", core.ErrBadRequest))
+				return
+			}
+			accountId = &i
+		}
+
+		treasureChestIdStr := r.FormValue("treasure-chest-id")
+		var treasureChestId *uuid.UUID
+		if treasureChestIdStr != "" {
+			i, err := uuid.Parse(treasureChestIdStr)
+			if err != nil {
+				core.HandleError(w, r, fmt.Errorf("could not parse treasure chest id: %w", core.ErrBadRequest))
+				return
+			}
+			treasureChestId = &i
+		}
+
+		valueF, err := strconv.ParseFloat(r.FormValue("value"), 64)
+		if err != nil {
+			core.HandleError(w, r, fmt.Errorf("could not parse value: %w", core.ErrBadRequest))
+			return
+		}
+		value := int64(math.Round(valueF * DECIMALS_MULTIPLIER))
+
+		timestamp, err := time.Parse("2006-01-02", r.FormValue("timestamp"))
+		if err != nil {
+			core.HandleError(w, r, fmt.Errorf("could not parse timestamp: %w", core.ErrBadRequest))
+			return
+		}
+
+		input := Transaction{
+			Id:              id,
+			AccountId:       accountId,
+			TreasureChestId: treasureChestId,
+			Value:           value,
+			Timestamp:       timestamp,
+			Party:           r.FormValue("party"),
+			Description:     r.FormValue("description"),
+		}
+
+		var transaction *Transaction
+		if idStr == "new" {
+			transaction, err = h.s.Add(r.Context(), nil, user, input)
+			if err != nil {
+				core.HandleError(w, r, err)
+				return
+			}
+		} else {
+			transaction, err = h.s.Update(r.Context(), user, input)
+			if err != nil {
+				core.HandleError(w, r, err)
+				return
+			}
+		}
+
+		accounts, err := h.account.GetAll(r.Context(), user)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		treasureChests, err := h.treasureChest.GetAll(r.Context(), user)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		accountMap, treasureChestMap := h.getTransactionData(accounts, treasureChests)
+		comp := TransactionItem(transaction, accountMap, treasureChestMap)
+		h.r.Render(r, w, comp)
+	}
+}
+
+func (h HandlerImpl) handleRecalculate() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		core.UpdateSpan(r)
+
+		user := core.GetUser(r)
+		if user == nil {
+			core.DoRedirect(w, r, "/auth/signin")
+			return
+		}
+
+		err := h.s.RecalculateBalances(r.Context(), user)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+
+		core.TriggerToastWithStatus(r.Context(), w, r, "success", "Balances recalculated, please refresh", http.StatusOK)
+	}
+}
+
+func (h HandlerImpl) handleDeleteTransaction() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		core.UpdateSpan(r)
+
+		user := core.GetUser(r)
+		if user == nil {
+			core.DoRedirect(w, r, "/auth/signin")
+			return
+		}
+
+		id := r.PathValue("id")
+
+		err := h.s.Delete(r.Context(), user, id)
+		if err != nil {
+			core.HandleError(w, r, err)
+			return
+		}
+	}
+}
+
+func (h HandlerImpl) getTransactionData(accounts []*account.Account, treasureChests []*treasure_chest_types.TreasureChest) (map[uuid.UUID]string, map[uuid.UUID]string) {
+	accountMap := make(map[uuid.UUID]string, 0)
+	for _, account := range accounts {
+		accountMap[account.Id] = account.Name
+	}
+	treasureChestMap := make(map[uuid.UUID]string, 0)
+	root := ""
+	for _, treasureChest := range treasureChests {
+		if treasureChest.ParentId == nil {
+			root = treasureChest.Name + " > "
+			treasureChestMap[treasureChest.Id] = treasureChest.Name
+		} else {
+			treasureChestMap[treasureChest.Id] = root + treasureChest.Name
+		}
+	}
+	return accountMap, treasureChestMap
+}
--- a/internal/transaction/service.go
+++ b/internal/transaction/service.go
@@ -0,0 +1,612 @@
+package transaction
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"spend-sparrow/internal/auth_types"
+	"spend-sparrow/internal/core"
+	"spend-sparrow/internal/transaction_recurring"
+	"spend-sparrow/internal/treasure_chest_types"
+	"strconv"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jmoiron/sqlx"
+)
+
+const page_size = 25
+
+type Service interface {
+	Add(ctx context.Context, tx *sqlx.Tx, user *auth_types.User, transaction Transaction) (*Transaction, error)
+	Update(ctx context.Context, user *auth_types.User, transaction Transaction) (*Transaction, error)
+	Get(ctx context.Context, user *auth_types.User, id string) (*Transaction, error)
+	GetAll(ctx context.Context, user *auth_types.User, filter TransactionItemsFilter) ([]*Transaction, error)
+	Delete(ctx context.Context, user *auth_types.User, id string) error
+
+	RecalculateBalances(ctx context.Context, user *auth_types.User) error
+	GenerateRecurringTransactions(ctx context.Context) error
+}
+
+type ServiceImpl struct {
+	db     *sqlx.DB
+	clock  core.Clock
+	random core.Random
+}
+
+func NewService(db *sqlx.DB, random core.Random, clock core.Clock) Service {
+	return ServiceImpl{
+		db:     db,
+		clock:  clock,
+		random: random,
+	}
+}
+
+func (s ServiceImpl) Add(ctx context.Context, tx *sqlx.Tx, user *auth_types.User, transactionInput Transaction) (*Transaction, error) {
+	if user == nil {
+		return nil, core.ErrUnauthorized
+	}
+
+	var err error
+	ownsTransaction := false
+	if tx == nil {
+		ownsTransaction = true
+		tx, err = s.db.BeginTxx(ctx, nil)
+		err = core.TransformAndLogDbError(ctx, "transaction Add", nil, err)
+		if err != nil {
+			return nil, err
+		}
+		defer func() {
+			_ = tx.Rollback()
+		}()
+	}
+
+	transaction, err := s.validateAndEnrichTransaction(ctx, tx, nil, user.Id, transactionInput)
+	if err != nil {
+		return nil, err
+	}
+
+	r, err := tx.NamedExecContext(ctx, `
+		INSERT INTO "transaction" (id, user_id, account_id, treasure_chest_id, value, timestamp, 
+			party, description, error, created_at, created_by)
+		VALUES (:id, :user_id, :account_id, :treasure_chest_id, :value, :timestamp, 
+			:party, :description, :error, :created_at, :created_by)`, transaction)
+	err = core.TransformAndLogDbError(ctx, "transaction Insert", r, err)
+	if err != nil {
+		return nil, err
+	}
+
+	if transaction.Error == nil && transaction.AccountId != nil {
+		r, err = tx.ExecContext(ctx, `
+			UPDATE account
+			SET current_balance = current_balance + ?
+			WHERE id = ? AND user_id = ?`, transaction.Value, transaction.AccountId, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction Add", r, err)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if transaction.Error == nil && transaction.TreasureChestId != nil {
+		r, err = tx.ExecContext(ctx, `
+			UPDATE treasure_chest
+			SET current_balance = current_balance + ?
+			WHERE id = ? AND user_id = ?`, transaction.Value, transaction.TreasureChestId, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction Add", r, err)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if ownsTransaction {
+		err = tx.Commit()
+		err = core.TransformAndLogDbError(ctx, "transaction Add", nil, err)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return transaction, nil
+}
+
+func (s ServiceImpl) Update(ctx context.Context, user *auth_types.User, input Transaction) (*Transaction, error) {
+	if user == nil {
+		return nil, core.ErrUnauthorized
+	}
+
+	tx, err := s.db.BeginTxx(ctx, nil)
+	err = core.TransformAndLogDbError(ctx, "transaction Update", nil, err)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		_ = tx.Rollback()
+	}()
+
+	transaction := &Transaction{}
+	err = tx.GetContext(ctx, transaction, `SELECT * FROM "transaction" WHERE user_id = ? AND id = ?`, user.Id, input.Id)
+	err = core.TransformAndLogDbError(ctx, "transaction Update", nil, err)
+	if err != nil {
+		if errors.Is(err, core.ErrNotFound) {
+			return nil, fmt.Errorf("transaction %v not found: %w", input.Id, core.ErrBadRequest)
+		}
+		return nil, core.ErrInternal
+	}
+
+	if transaction.Error == nil && transaction.AccountId != nil {
+		r, err := tx.ExecContext(ctx, `
+			UPDATE account
+			SET current_balance = current_balance - ?
+			WHERE id = ? AND user_id = ?`, transaction.Value, transaction.AccountId, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction Update", r, err)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if transaction.Error == nil && transaction.TreasureChestId != nil {
+		r, err := tx.ExecContext(ctx, `
+			UPDATE treasure_chest
+			SET current_balance = current_balance - ?
+			WHERE id = ? AND user_id = ?`, transaction.Value, transaction.TreasureChestId, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction Update", r, err)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	transaction, err = s.validateAndEnrichTransaction(ctx, tx, transaction, user.Id, input)
+	if err != nil {
+		return nil, err
+	}
+
+	if transaction.Error == nil && transaction.AccountId != nil {
+		r, err := tx.ExecContext(ctx, `
+			UPDATE account
+			SET current_balance = current_balance + ?
+			WHERE id = ? AND user_id = ?`, transaction.Value, transaction.AccountId, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction Update", r, err)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if transaction.Error == nil && transaction.TreasureChestId != nil {
+		r, err := tx.ExecContext(ctx, `
+			UPDATE treasure_chest
+			SET current_balance = current_balance + ?
+			WHERE id = ? AND user_id = ?`, transaction.Value, transaction.TreasureChestId, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction Update", r, err)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	r, err := tx.NamedExecContext(ctx, `
+		UPDATE "transaction"
+		SET
+			account_id = :account_id,
+			treasure_chest_id = :treasure_chest_id,
+			value = :value,
+			timestamp = :timestamp,
+			party = :party,
+			description = :description,
+			error = :error,
+			updated_at = :updated_at,
+			updated_by = :updated_by
+		WHERE id = :id
+			AND user_id = :user_id`, transaction)
+	err = core.TransformAndLogDbError(ctx, "transaction Update", r, err)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Commit()
+	err = core.TransformAndLogDbError(ctx, "transaction Update", nil, err)
+	if err != nil {
+		return nil, err
+	}
+
+	return transaction, nil
+}
+
+func (s ServiceImpl) Get(ctx context.Context, user *auth_types.User, id string) (*Transaction, error) {
+	if user == nil {
+		return nil, core.ErrUnauthorized
+	}
+	uuid, err := uuid.Parse(id)
+	if err != nil {
+		slog.ErrorContext(ctx, "transaction get", "err", err)
+		return nil, fmt.Errorf("could not parse Id: %w", core.ErrBadRequest)
+	}
+
+	var transaction Transaction
+	err = s.db.GetContext(ctx, &transaction, `SELECT * FROM "transaction" WHERE user_id = ? AND id = ?`, user.Id, uuid)
+	err = core.TransformAndLogDbError(ctx, "transaction Get", nil, err)
+	if err != nil {
+		if errors.Is(err, core.ErrNotFound) {
+			return nil, fmt.Errorf("transaction %v not found: %w", id, core.ErrBadRequest)
+		}
+		return nil, core.ErrInternal
+	}
+
+	return &transaction, nil
+}
+
+func (s ServiceImpl) GetAll(ctx context.Context, user *auth_types.User, filter TransactionItemsFilter) ([]*Transaction, error) {
+	if user == nil {
+		return nil, core.ErrUnauthorized
+	}
+
+	var (
+		page   int64
+		offset int64
+		err    error
+	)
+	if filter.Page != "" {
+		page, err = strconv.ParseInt(filter.Page, 10, 64)
+		if err != nil {
+			offset = 0
+		} else {
+			offset = page - 1
+			offset *= page_size
+		}
+	}
+
+	transactions := make([]*Transaction, 0)
+	err = s.db.SelectContext(ctx, &transactions, `
+		SELECT * 
+		FROM "transaction" 
+		WHERE user_id = ? 
+			AND ($1 = '' OR account_id = $1)
+			AND ($2 = '' OR treasure_chest_id = $2)
+			AND ($3 = '' 
+				OR ($3 = "true" AND error IS NOT NULL)
+				OR ($3 = "false" AND error IS NULL)
+		  )
+		ORDER BY timestamp DESC, created_at DESC
+		LIMIT $4 OFFSET $5
+		`,
+		user.Id,
+		filter.AccountId,
+		filter.TreasureChestId,
+		filter.Error,
+		page_size,
+		offset)
+	err = core.TransformAndLogDbError(ctx, "transaction GetAll", nil, err)
+	if err != nil {
+		return nil, err
+	}
+
+	return transactions, nil
+}
+
+func (s ServiceImpl) Delete(ctx context.Context, user *auth_types.User, id string) error {
+	if user == nil {
+		return core.ErrUnauthorized
+	}
+	uuid, err := uuid.Parse(id)
+	if err != nil {
+		slog.ErrorContext(ctx, "transaction delete", "err", err)
+		return fmt.Errorf("could not parse Id: %w", core.ErrBadRequest)
+	}
+
+	tx, err := s.db.BeginTxx(ctx, nil)
+	err = core.TransformAndLogDbError(ctx, "transaction Delete", nil, err)
+	if err != nil {
+		return nil
+	}
+	defer func() {
+		_ = tx.Rollback()
+	}()
+
+	var transaction Transaction
+	err = tx.GetContext(ctx, &transaction, `SELECT * FROM "transaction" WHERE user_id = ? AND id = ?`, user.Id, uuid)
+	err = core.TransformAndLogDbError(ctx, "transaction Delete", nil, err)
+	if err != nil {
+		return err
+	}
+
+	if transaction.Error == nil && transaction.AccountId != nil {
+		r, err := tx.ExecContext(ctx, `
+			UPDATE account
+			SET current_balance = current_balance - ?
+			WHERE id = ?
+				AND user_id = ?`, transaction.Value, transaction.AccountId, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction Delete", r, err)
+		if err != nil && !errors.Is(err, core.ErrNotFound) {
+			return err
+		}
+	}
+
+	if transaction.Error == nil && transaction.TreasureChestId != nil {
+		r, err := tx.ExecContext(ctx, `
+			UPDATE treasure_chest
+			SET current_balance = current_balance - ?
+			WHERE id = ?
+				AND user_id = ?`, transaction.Value, transaction.TreasureChestId, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction Delete", r, err)
+		if err != nil && !errors.Is(err, core.ErrNotFound) {
+			return err
+		}
+	}
+
+	r, err := tx.ExecContext(ctx, "DELETE FROM \"transaction\" WHERE id = ? AND user_id = ?", uuid, user.Id)
+	err = core.TransformAndLogDbError(ctx, "transaction Delete", r, err)
+	if err != nil {
+		return err
+	}
+
+	err = tx.Commit()
+	err = core.TransformAndLogDbError(ctx, "transaction Delete", nil, err)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s ServiceImpl) RecalculateBalances(ctx context.Context, user *auth_types.User) error {
+	if user == nil {
+		return core.ErrUnauthorized
+	}
+
+	tx, err := s.db.BeginTxx(ctx, nil)
+	err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", nil, err)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = tx.Rollback()
+	}()
+
+	r, err := tx.ExecContext(ctx, `
+		UPDATE account
+		SET current_balance = 0
+		WHERE user_id = ?`, user.Id)
+	err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", r, err)
+	if err != nil && !errors.Is(err, core.ErrNotFound) {
+		return err
+	}
+
+	r, err = tx.ExecContext(ctx, `
+		UPDATE treasure_chest
+		SET current_balance = 0
+		WHERE user_id = ?`, user.Id)
+	err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", r, err)
+	if err != nil && !errors.Is(err, core.ErrNotFound) {
+		return err
+	}
+
+	rows, err := tx.QueryxContext(ctx, `
+		SELECT *
+		FROM "transaction" 
+		WHERE user_id = ?`, user.Id)
+	err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", nil, err)
+	if err != nil && !errors.Is(err, core.ErrNotFound) {
+		return err
+	}
+	defer func() {
+		err := rows.Close()
+		if err != nil {
+			slog.ErrorContext(ctx, "transaction RecalculateBalances", "err", err)
+		}
+	}()
+
+	var transaction Transaction
+	for rows.Next() {
+		err = rows.StructScan(&transaction)
+		err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", nil, err)
+		if err != nil {
+			return err
+		}
+
+		s.updateErrors(&transaction)
+		r, err = tx.ExecContext(ctx, `
+			UPDATE "transaction" 
+			SET error = ? 
+			WHERE user_id = ? 
+				AND id = ?`, transaction.Error, user.Id, transaction.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", r, err)
+		if err != nil {
+			return err
+		}
+
+		if transaction.Error != nil {
+			continue
+		}
+
+		if transaction.AccountId != nil {
+			r, err = tx.ExecContext(ctx, `
+				UPDATE account
+				SET current_balance = current_balance + ?
+				WHERE id = ? AND user_id = ?`, transaction.Value, transaction.AccountId, user.Id)
+			err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", r, err)
+			if err != nil {
+				return err
+			}
+		}
+		if transaction.TreasureChestId != nil {
+			r, err = tx.ExecContext(ctx, `
+				UPDATE treasure_chest
+				SET current_balance = current_balance + ?
+				WHERE id = ? AND user_id = ?`, transaction.Value, transaction.TreasureChestId, user.Id)
+			err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", r, err)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	err = tx.Commit()
+	err = core.TransformAndLogDbError(ctx, "transaction RecalculateBalances", nil, err)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s ServiceImpl) GenerateRecurringTransactions(ctx context.Context) error {
+	now := s.clock.Now()
+
+	tx, err := s.db.BeginTxx(ctx, nil)
+	err = core.TransformAndLogDbError(ctx, "transaction GenerateRecurringTransactions", nil, err)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = tx.Rollback()
+	}()
+
+	recurringTransactions := make([]*transaction_recurring.TransactionRecurring, 0)
+	err = tx.SelectContext(ctx, &recurringTransactions, `
+		SELECT * FROM transaction_recurring WHERE next_execution <= ?`,
+		now)
+	err = core.TransformAndLogDbError(ctx, "transaction GenerateRecurringTransactions", nil, err)
+	if err != nil {
+		return err
+	}
+
+	for _, transactionRecurring := range recurringTransactions {
+		user := &auth_types.User{
+			Id: transactionRecurring.UserId,
+		}
+		transaction := Transaction{
+			Timestamp:   *transactionRecurring.NextExecution,
+			Party:       transactionRecurring.Party,
+			Description: transactionRecurring.Description,
+
+			TreasureChestId: transactionRecurring.TreasureChestId,
+			Value:           transactionRecurring.Value,
+		}
+
+		_, err = s.Add(ctx, tx, user, transaction)
+		if err != nil {
+			return err
+		}
+
+		nextExecution := transactionRecurring.NextExecution.AddDate(0, int(transactionRecurring.IntervalMonths), 0)
+		r, err := tx.ExecContext(ctx, `UPDATE transaction_recurring SET next_execution = ? WHERE id = ? AND user_id = ?`,
+			nextExecution, transactionRecurring.Id, user.Id)
+		err = core.TransformAndLogDbError(ctx, "transaction GenerateRecurringTransactions", r, err)
+		if err != nil {
+			return err
+		}
+	}
+
+	err = tx.Commit()
+	err = core.TransformAndLogDbError(ctx, "transaction GenerateRecurringTransactions", nil, err)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s ServiceImpl) validateAndEnrichTransaction(ctx context.Context, tx *sqlx.Tx, oldTransaction *Transaction, userId uuid.UUID, input Transaction) (*Transaction, error) {
+	var (
+		id        uuid.UUID
+		createdAt time.Time
+		createdBy uuid.UUID
+		updatedAt *time.Time
+		updatedBy uuid.UUID
+
+		err      error
+		rowCount int
+	)
+
+	if oldTransaction == nil {
+		id, err = s.random.UUID(ctx)
+		if err != nil {
+			return nil, core.ErrInternal
+		}
+		createdAt = s.clock.Now()
+		createdBy = userId
+	} else {
+		id = oldTransaction.Id
+		createdAt = oldTransaction.CreatedAt
+		createdBy = oldTransaction.CreatedBy
+		time := s.clock.Now()
+		updatedAt = &time
+		updatedBy = userId
+	}
+
+	if input.AccountId != nil {
+		err = tx.GetContext(ctx, &rowCount, `SELECT COUNT(*) FROM account WHERE id = ? AND user_id = ?`, input.AccountId, userId)
+		err = core.TransformAndLogDbError(ctx, "transaction validate", nil, err)
+		if err != nil {
+			return nil, err
+		}
+		if rowCount == 0 {
+			slog.ErrorContext(ctx, "transaction validate", "err", err)
+			return nil, fmt.Errorf("account not found: %w", core.ErrBadRequest)
+		}
+	}
+
+	if input.TreasureChestId != nil {
+		var treasureChest treasure_chest_types.TreasureChest
+		err = tx.GetContext(ctx, &treasureChest, `SELECT * FROM treasure_chest WHERE id = ? AND user_id = ?`, input.TreasureChestId, userId)
+		err = core.TransformAndLogDbError(ctx, "transaction validate", nil, err)
+		if err != nil {
+			if errors.Is(err, core.ErrNotFound) {
+				return nil, fmt.Errorf("treasure chest not found: %w", core.ErrBadRequest)
+			}
+			return nil, err
+		}
+		if treasureChest.ParentId == nil {
+			return nil, fmt.Errorf("treasure chest is a group: %w", core.ErrBadRequest)
+		}
+	}
+
+	if input.Party != "" {
+		err = core.ValidateString(input.Party, "party")
+		if err != nil {
+			return nil, err
+		}
+	}
+	if input.Description != "" {
+		err = core.ValidateString(input.Description, "description")
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	transaction := Transaction{
+		Id:     id,
+		UserId: userId,
+
+		AccountId:       input.AccountId,
+		TreasureChestId: input.TreasureChestId,
+		Value:           input.Value,
+		Timestamp:       input.Timestamp,
+		Party:           input.Party,
+		Description:     input.Description,
+		Error:           nil,
+
+		CreatedAt: createdAt,
+		CreatedBy: createdBy,
+		UpdatedAt: updatedAt,
+		UpdatedBy: &updatedBy,
+	}
+
+	s.updateErrors(&transaction)
+
+	return &transaction, nil
+}
+
+func (s ServiceImpl) updateErrors(t *Transaction) {
+	errorStr := ""
+
+	switch {
+	case (t.AccountId != nil && t.TreasureChestId != nil && t.Value > 0) ||
+		(t.AccountId == nil && t.TreasureChestId == nil):
+		errorStr = "either an account or a treasure chest needs to be specified"
+	case t.Value == 0:
+		errorStr = "\"value\" needs to be specified"
+	}
+
+	if errorStr == "" {
+		t.Error = nil
+	} else {
+		t.Error = &errorStr
+	}
+}
--- a/internal/transaction/template.templ
+++ b/internal/transaction/template.templ
@@ -0,0 +1,321 @@
+package transaction
+
+import (
+	"fmt"
+	"github.com/google/uuid"
+	"spend-sparrow/internal/account"
+	"spend-sparrow/internal/core"
+	"spend-sparrow/internal/template/svg"
+	"spend-sparrow/internal/treasure_chest_types"
+	"time"
+)
+
+templ TransactionComp(items templ.Component, filter TransactionItemsFilter, accounts []*account.Account, treasureChests []*treasure_chest_types.TreasureChest) {
+	<div class="max-w-6xl mt-10 mx-auto">
+		<div class="flex items-center gap-4">
+			<form
+				id="transactionFilterForm"
+				hx-get="/transaction"
+				hx-target="#transaction-items"
+				hx-push-url="true"
+				hx-trigger="change"
+			>
+				<select name="account-id" class="bg-white input">
+					<option value="">- Filter Acount -</option>
+					for _, account := range accounts {
+						<option
+							value={ account.Id.String() }
+							selected?={ filter.AccountId == account.Id.String() }
+						>{ account.Name }</option>
+					}
+				</select>
+				<select name="treasure-chest-id" class="bg-white input">
+					<option value="">- Filter Treasure Chest -</option>
+					for _, parent := range treasureChests {
+						if parent.ParentId == nil {
+							<optgroup label={ parent.Name }>
+								for _, child := range treasureChests {
+									if child.ParentId != nil && *child.ParentId == parent.Id {
+										<option
+											value={ child.Id.String() }
+											selected?={ filter.TreasureChestId == child.Id.String() }
+										>{ child.Name }</option>
+									}
+								}
+							</optgroup>
+						}
+					}
+				</select>
+				<select name="error" class="bg-white input">
+					<option value="">- Filter Error -</option>
+					<option
+						value="true"
+						selected?={ filter.Error == "true" }
+					>Has Errors</option>
+					<option
+						value="false"
+						selected?={ filter.Error == "false" }
+					>Has no Errors</option>
+				</select>
+				<input id="page" name="page" type="hidden" value={ filter.Page }/>
+			</form>
+			<button
+				hx-get="/transaction/new"
+				hx-target="#transaction-items"
+				hx-swap="afterbegin"
+				class="button button-primary ml-auto px-2 flex items-center gap-2 justify-center"
+			>
+				@svg.Plus()
+				<p>New Transaction</p>
+			</button>
+		</div>
+		<div class="flex justify-end items-center gap-5 mt-5">
+			<button id="pagePrev1" class="text-2xl p-2 text-yellow-700 font-black hover:bg-gray-200 rounded-lg decoration-yellow-400 decoration-[0.25rem] hover:underline">
+				&lt;
+			</button>
+			<span class="text-gray-400 text-sm">Page: <span class="text-gray-800 text-xl" id="page1">{ getPageNumber(filter.Page) }</span></span>
+			<button id="pageNext1" class="text-2xl p-2 text-yellow-700 font-black hover:bg-gray-200 rounded-lg decoration-yellow-400 decoration-[0.25rem] hover:underline">
+				&gt;
+			</button>
+		</div>
+		@items
+		<div class="flex justify-end items-center gap-5 mt-5">
+			<button id="pagePrev2" class="text-2xl p-2 text-yellow-700 font-black hover:bg-gray-200 rounded-lg decoration-yellow-400 decoration-[0.25rem] hover:underline">
+				&lt;
+			</button>
+			<span class="text-gray-400 text-sm">Page: <span class="text-gray-800 text-xl" id="page2">{ getPageNumber(filter.Page) }</span></span>
+			<button id="pageNext2" class="text-2xl p-2 text-yellow-700 font-black hover:bg-gray-200 rounded-lg decoration-yellow-400 decoration-[0.25rem] hover:underline">
+				&gt;
+			</button>
+		</div>
+	</div>
+}
+
+templ TransactionItems(transactions []*Transaction, accounts, treasureChests map[uuid.UUID]string) {
+	<div id="transaction-items" class="my-6">
+		for _, transaction := range transactions {
+			@TransactionItem(transaction, accounts, treasureChests)
+		}
+	</div>
+}
+
+templ EditTransaction(transaction *Transaction, accounts []*account.Account, treasureChests []*treasure_chest_types.TreasureChest) {
+	{{
+		var (
+			timestamp time.Time
+
+			id        string
+			cancelUrl string
+		)
+		party := ""
+		description := ""
+		accountId := ""
+		value := "0.00"
+		treasureChestId := ""
+		if transaction == nil {
+			timestamp = time.Now().UTC().Truncate(time.Minute)
+
+			id = "new"
+			cancelUrl = "/empty"
+		} else {
+			timestamp = transaction.Timestamp.UTC().Truncate(time.Minute)
+			party = transaction.Party
+			description = transaction.Description
+			if transaction.AccountId != nil {
+				accountId = transaction.AccountId.String()
+			}
+			if transaction.TreasureChestId != nil {
+				treasureChestId = transaction.TreasureChestId.String()
+			}
+			value = formatFloat(transaction.Value)
+
+			id = transaction.Id.String()
+			cancelUrl = "/transaction/" + id
+		}
+	}}
+	<div id="transaction" class="border-1 border-gray-300 w-full my-4 p-4 bg-gray-50 rounded-lg">
+		<form
+			hx-post={ "/transaction/" + id }
+			hx-target="closest #transaction"
+			hx-swap="outerHTML"
+			class="text-xl flex justify-end gap-4 items-center"
+		>
+			<div class="grid grid-cols-[auto_auto] items-center gap-4 mr-auto">
+				<label for="timestamp" class="text-sm text-gray-500">Transaction Date</label>
+				<input
+					autofocus
+					name="timestamp"
+					type="date"
+					value={ timestamp.String() }
+					class="bg-white input datetime"
+				/>
+				<label for="party" class="text-sm text-gray-500">Party</label>
+				<input
+					name="party"
+					type="text"
+					value={ party }
+					class="mr-auto bg-white input"
+				/>
+				<label for="description" class="text-sm text-gray-500">Description</label>
+				<input
+					name="description"
+					type="text"
+					value={ description }
+					class="mr-auto bg-white input"
+				/>
+				<label for="value" class="text-sm text-gray-500">Value (€)</label>
+				<input
+					name="value"
+					step="0.01"
+					type="number"
+					value={ value }
+					class="bg-white input"
+				/>
+				<label for="account-id" class="text-sm text-gray-500">Account</label>
+				<select
+					name="account-id"
+					class="bg-white input"
+				>
+					<option value="">-</option>
+					for _, account := range accounts {
+						<option selected?={ account.Id.String() == accountId } value={ account.Id.String() }>{ account.Name }</option>
+					}
+				</select>
+				<label for="treasure-chest-id" class="text-sm text-gray-500">Treasure Chest</label>
+				<select name="treasure-chest-id" class="bg-white input">
+					<option value="">- Filter Treasure Chest -</option>
+					for _, parent := range treasureChests {
+						if parent.ParentId == nil {
+							<optgroup label={ parent.Name }>
+								for _, child := range treasureChests {
+									if child.ParentId != nil && *child.ParentId == parent.Id {
+										<option
+											value={ child.Id.String() }
+											selected?={ treasureChestId == child.Id.String() }
+										>{ child.Name }</option>
+									}
+								}
+							</optgroup>
+						}
+					}
+				</select>
+			</div>
+			<button type="submit" class="button button-neglect px-1 flex items-center gap-2">
+				@svg.Save()
+				<span>
+					Save
+				</span>
+			</button>
+			<button
+				hx-get={ cancelUrl }
+				hx-target="closest #transaction"
+				hx-swap="outerHTML"
+				class="button button-neglect px-1 flex items-center gap-2"
+			>
+				<span class="h-4 w-4">
+					@svg.Cancel()
+				</span>
+				<span>
+					Cancel
+				</span>
+			</button>
+		</form>
+	</div>
+}
+
+templ TransactionItem(transaction *Transaction, accounts, treasureChests map[uuid.UUID]string) {
+	{{
+		background := "bg-gray-50"
+		if transaction.Error != nil {
+			background = "bg-yellow-50"
+		}
+	}}
+	<div
+		id="transaction"
+		class={ "mt-4 border-1 grid grid-cols-[auto_auto_1fr_1fr_auto_auto_auto_auto] gap-4 items-center text-xl border-gray-300 w-full p-4 rounded-lg " + background }
+		if transaction.Error != nil {
+			title={ *transaction.Error }
+		}
+	>
+		<p class="mr-auto datetime">{ transaction.Timestamp.String() }</p>
+		<div class="w-6">
+			if transaction.Error != nil {
+				@svg.Info()
+			}
+		</div>
+		<div>
+			<p class="text-sm text-gray-500">
+				if transaction.AccountId != nil {
+					{ accounts[*transaction.AccountId] }
+				} else {
+					&nbsp;
+				}
+			</p>
+			<p class="text-sm text-gray-500">
+				if transaction.TreasureChestId != nil {
+					{ treasureChests[*transaction.TreasureChestId] }
+				} else {
+					&nbsp;
+				}
+			</p>
+		</div>
+		<div>
+			<p class="text-sm text-gray-500">
+				if transaction.Party != "" {
+					{ transaction.Party }
+				} else {
+					&nbsp;
+				}
+			</p>
+			<p class="text-sm text-gray-500">
+				if transaction.Description != "" {
+					{ transaction.Description }
+				} else {
+					&nbsp;
+				}
+			</p>
+		</div>
+		if transaction.Value < 0 {
+			<p class="mr-8 min-w-22 text-right text-red-700">{ core.FormatEuros(transaction.Value) }</p>
+		} else {
+			<p class="mr-8 w-22 text-right text-green-700">{ core.FormatEuros(transaction.Value) }</p>
+		}
+		<button
+			hx-get={ "/transaction/" + transaction.Id.String() + "?edit=true" }
+			hx-target="closest #transaction"
+			hx-swap="outerHTML"
+			class="button button-neglect px-1 flex items-center gap-2"
+		>
+			@svg.Edit()
+			<span>
+				Edit
+			</span>
+		</button>
+		<button
+			hx-delete={ "/transaction/" + transaction.Id.String() }
+			hx-target="closest #transaction"
+			hx-swap="outerHTML"
+			hx-confirm="Are you sure you want to delete this transaction?"
+			class="button button-neglect px-1 flex items-center gap-2"
+		>
+			@svg.Delete()
+			<span>
+				Delete
+			</span>
+		</button>
+	</div>
+}
+
+func formatFloat(balance int64) string {
+
+	euros := float64(balance) / 100
+	return fmt.Sprintf("%.2f", euros)
+}
+
+func getPageNumber(page string) string {
+	if page == "" {
+		return "1"
+	} else {
+		return page
+	}
+}
--- a/internal/transaction/types.go
+++ b/internal/transaction/types.go
@@ -0,0 +1,55 @@
+package transaction
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// Transaction is at the center of the application.
+//
+// Every piece of data should be calculated based on transactions.
+// This means potential calculation errors can be fixed later in time.
+//
+// If it becomes necessary to precalculate snapshots for performance reasons, this can be done in the future.
+// But the transaction should always be the source of truth.
+//
+// There are the following constallations and their explanation:
+//
+//	Account	| TreasureChest	| Value	| Description
+//	--------|---------------|-------|----------------
+//	Y		| Y				| +		| Invalid
+//	Y		| Y				| -		| Expense
+//	Y		| N				| +		| Deposit
+//	Y		| N				| -		| Withdrawal (for moving between accounts)
+//	N		| Y				| +		| Saving
+//	N		| Y				| -		| Withdrawal (for moving between treasure chests)
+//	N		| N				| +		| Invalid
+//	N		| N				| -		| Invalid
+type Transaction struct {
+	Id     uuid.UUID `db:"id"`
+	UserId uuid.UUID `db:"user_id"`
+
+	Timestamp   time.Time `db:"timestamp"`
+	Party       string    `db:"party"`
+	Description string    `db:"description"`
+
+	AccountId       *uuid.UUID `db:"account_id"`
+	TreasureChestId *uuid.UUID `db:"treasure_chest_id"`
+	Value           int64      `db:"value"`
+
+	// If an error is present, then the transaction is not valid and should not be used for calculations.
+	Error     *string   `db:"error"`
+	CreatedAt time.Time `db:"created_at"`
+	// Either a user_id or a transaction_recurring_id
+	CreatedBy uuid.UUID  `db:"created_by"`
+	UpdatedAt *time.Time `db:"updated_at"`
+	UpdatedBy *uuid.UUID `db:"updated_by"`
+}
+
+type TransactionItemsFilter struct {
+	AccountId       string
+	TreasureChestId string
+	Error           string
+	Page            string
+}