budgeteer/server/budgeting.go

package server

import (
	"fmt"
	"net/http"
	"strconv"
	"time"

	"git.javil.eu/jacob1123/budgeteer/postgres"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

func getFirstOfMonth(year, month int, location *time.Location) time.Time {
	return time.Date(year, time.Month(month), 1, 0, 0, 0, 0, location)
}

func getFirstOfMonthTime(date time.Time) time.Time {
	var monthM time.Month
	year, monthM, _ := date.Date()
	month := int(monthM)
	return getFirstOfMonth(year, month, date.Location())
}

type CategoryWithBalance struct {
	*postgres.GetCategoriesRow
	Available          postgres.Numeric
	AvailableLastMonth postgres.Numeric
	Activity           postgres.Numeric
	Assigned           postgres.Numeric
}

func getDate(c *gin.Context) (time.Time, error) {
	var year, month int
	yearString := c.Param("year")
	monthString := c.Param("month")
	if yearString == "" && monthString == "" {
		return getFirstOfMonthTime(time.Now()), nil
	}

	year, err := strconv.Atoi(yearString)
	if err != nil {
		return time.Time{}, fmt.Errorf("parse year: %w", err)
	}

	month, err = strconv.Atoi(monthString)
	if err != nil {
		return time.Time{}, fmt.Errorf("parse month: %w", err)
	}

	return getFirstOfMonth(year, month, time.Now().Location()), nil
}

func (h *Handler) budgetingForMonth(c *gin.Context) {
	budgetID := c.Param("budgetid")
	budgetUUID, err := uuid.Parse(budgetID)
	if err != nil {
		c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"budgetid missing from URL"})
		return
	}

	budget, err := h.Service.GetBudget(c.Request.Context(), budgetUUID)
	if err != nil {
		c.AbortWithError(http.StatusBadRequest, err)
		return
	}

	firstOfMonth, err := getDate(c)
	if err != nil {
		c.Redirect(http.StatusTemporaryRedirect, "/budget/"+budgetUUID.String())
		return
	}

	categories, err := h.Service.GetCategories(c.Request.Context(), budgetUUID)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	firstOfNextMonth := firstOfMonth.AddDate(0, 1, 0)
	cumultativeBalances, err := h.Service.GetCumultativeBalances(c.Request.Context(), budgetUUID)
	if err != nil {
		c.AbortWithStatusJSON(http.StatusInternalServerError, ErrorResponse{fmt.Sprintf("error loading balances: %s", err)})
		return
	}

	// skip everything in the future
	categoriesWithBalance, moneyUsed, err := h.calculateBalances(
		c, budget, firstOfNextMonth, firstOfMonth, categories, cumultativeBalances)
	if err != nil {
		return
	}

	availableBalance := postgres.NewZeroNumeric()
	for _, cat := range categories {
		if cat.ID != budget.IncomeCategoryID {
			continue
		}
		availableBalance = moneyUsed

		for _, bal := range cumultativeBalances {
			if bal.CategoryID != cat.ID {
				continue
			}

			if !bal.Date.Before(firstOfNextMonth) {
				continue
			}

			availableBalance = availableBalance.Add(bal.Transactions)
		}
	}

	data := struct {
		Categories       []CategoryWithBalance
		AvailableBalance postgres.Numeric
	}{categoriesWithBalance, availableBalance}
	c.JSON(http.StatusOK, data)
}

func (h *Handler) budgeting(c *gin.Context) {
	budgetID := c.Param("budgetid")
	budgetUUID, err := uuid.Parse(budgetID)
	if err != nil {
		c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"budgetid missing from URL"})
		return
	}

	budget, err := h.Service.GetBudget(c.Request.Context(), budgetUUID)
	if err != nil {
		c.AbortWithError(http.StatusNotFound, err)
		return
	}

	accounts, err := h.Service.GetAccountsWithBalance(c.Request.Context(), budgetUUID)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	data := struct {
		Accounts []postgres.GetAccountsWithBalanceRow
		Budget   postgres.Budget
	}{accounts, budget}

	c.JSON(http.StatusOK, data)
}

func (h *Handler) calculateBalances(c *gin.Context, budget postgres.Budget, firstOfNextMonth time.Time, firstOfMonth time.Time, categories []postgres.GetCategoriesRow, cumultativeBalances []postgres.GetCumultativeBalancesRow) ([]CategoryWithBalance, postgres.Numeric, error) {
	categoriesWithBalance := []CategoryWithBalance{}
	hiddenCategory := CategoryWithBalance{
		GetCategoriesRow: &postgres.GetCategoriesRow{
			Name:  "",
			Group: "Hidden Categories",
		},
		Available:          postgres.NewZeroNumeric(),
		AvailableLastMonth: postgres.NewZeroNumeric(),
		Activity:           postgres.NewZeroNumeric(),
		Assigned:           postgres.NewZeroNumeric(),
	}

	moneyUsed := postgres.NewZeroNumeric()
	for i := range categories {
		cat := &categories[i]
		categoryWithBalance := CategoryWithBalance{
			GetCategoriesRow:   cat,
			Available:          postgres.NewZeroNumeric(),
			AvailableLastMonth: postgres.NewZeroNumeric(),
			Activity:           postgres.NewZeroNumeric(),
			Assigned:           postgres.NewZeroNumeric(),
		}
		for _, bal := range cumultativeBalances {
			if bal.CategoryID != cat.ID {
				continue
			}

			if !bal.Date.Before(firstOfNextMonth) {
				continue
			}

			moneyUsed = moneyUsed.Sub(bal.Assignments)
			categoryWithBalance.Available = categoryWithBalance.Available.Add(bal.Assignments)
			categoryWithBalance.Available = categoryWithBalance.Available.Add(bal.Transactions)
			if !categoryWithBalance.Available.IsPositive() && bal.Date.Before(firstOfMonth) {
				moneyUsed = moneyUsed.Add(categoryWithBalance.Available)
				categoryWithBalance.Available = postgres.NewZeroNumeric()
			}

			if bal.Date.Before(firstOfMonth) {
				categoryWithBalance.AvailableLastMonth = categoryWithBalance.Available
			} else if bal.Date.Before(firstOfNextMonth) {
				categoryWithBalance.Activity = bal.Transactions
				categoryWithBalance.Assigned = bal.Assignments
			}
		}

		// do not show hidden categories
		if cat.Group == "Hidden Categories" {
			hiddenCategory.Available = hiddenCategory.Available.Add(categoryWithBalance.Available)
			hiddenCategory.AvailableLastMonth = hiddenCategory.AvailableLastMonth.Add(categoryWithBalance.AvailableLastMonth)
			hiddenCategory.Activity = hiddenCategory.Activity.Add(categoryWithBalance.Activity)
			hiddenCategory.Assigned = hiddenCategory.Assigned.Add(categoryWithBalance.Assigned)
			continue
		}

		if cat.ID == budget.IncomeCategoryID {
			continue
		}

		categoriesWithBalance = append(categoriesWithBalance, categoryWithBalance)
	}

	categoriesWithBalance = append(categoriesWithBalance, hiddenCategory)

	return categoriesWithBalance, moneyUsed, nil
}