Skip to content

armgit / lyftr

Public Imported from GitHub
0

Self-hosted fitness tracker. Log workouts, track nutrition, and monitor progress. Docker deployment, mobile-friendly.

4.5 KB
Raw Blame
package controllers

import (
	"database/sql"
	"strconv"
	"time"

	"github.com/Cawlumm/lyftr-backend/middleware"
	"github.com/Cawlumm/lyftr-backend/models"
	"github.com/Cawlumm/lyftr-backend/stores"
	"github.com/Cawlumm/lyftr-backend/utils"
	"github.com/gin-gonic/gin"
)

func (h *Handler) ListWeightLogs(c *gin.Context) {
	uid := middleware.UserID(c)
	f := stores.WeightFilter{Limit: 90}
	if l, err := strconv.Atoi(c.Query("limit")); err == nil && l > 0 && l <= 1000 {
		f.Limit = l
	}
	if o, err := strconv.Atoi(c.Query("offset")); err == nil && o >= 0 {
		f.Offset = o
	}

	// `from`/`to` name days in the user's diary, and every row carries the day it was
	// filed under, so this is a range over stored days: no zone, no conversion, nothing
	// that can move later. Validated through resolveQueryDay so a range bound and a
	// single-day lookup cannot disagree about what a day string is.
	//
	// Day-only is also what every peer range API takes (Fitbit's food log `date`,
	// Garmin's `calendarDate`). An instant-bounded RFC3339 variant used to live here
	// for exact windows; no client ever sent one, and it was a second way to ask the
	// same question through a different column.
	if from := c.Query("from"); from != "" {
		day, ok := h.resolveQueryDay(uid, from)
		if !ok {
			utils.Fail(c, utils.CodeInvalidFromDate, nil)
			return
		}
		f.FromDay = &day
	}
	if to := c.Query("to"); to != "" {
		day, ok := h.resolveQueryDay(uid, to)
		if !ok {
			utils.Fail(c, utils.CodeInvalidToDate, nil)
			return
		}
		f.ToDay = &day
	}

	logs, err := h.s.Weight.List(uid, f)
	if utils.DBError(c, err) {
		return
	}
	utils.OK(c, logs)
}

func (h *Handler) LogWeight(c *gin.Context) {
	uid := middleware.UserID(c)
	var req models.LogWeightRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.BindError(c, err)
		return
	}
	if err := validate.Struct(req); err != nil {
		utils.ValidationError(c, err)
		return
	}
	req.LoggedAt = normalizeLoggedAt(req.LoggedAt)

	day, ok := h.resolveDay(uid, req.LoggedOn, req.LoggedAt)
	if !ok {
		utils.Fail(c, utils.CodeInvalidLoggedOn, nil)
		return
	}
	log, err := h.s.Weight.UpsertForDay(uid, req, day)
	if utils.DBError(c, err) {
		return
	}
	utils.Created(c, log)
}

func (h *Handler) GetWeightLog(c *gin.Context) {
	uid := middleware.UserID(c)
	lid, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		utils.Fail(c, utils.CodeInvalidID, nil)
		return
	}
	log, err := h.s.Weight.Get(uid, lid)
	if err == sql.ErrNoRows {
		utils.Fail(c, utils.CodeEntryNotFound, nil)
		return
	}
	if utils.DBError(c, err) {
		return
	}
	utils.OK(c, log)
}

func (h *Handler) UpdateWeightLog(c *gin.Context) {
	uid := middleware.UserID(c)
	lid, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		utils.Fail(c, utils.CodeInvalidID, nil)
		return
	}
	var req models.LogWeightRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.BindError(c, err)
		return
	}
	if err := validate.Struct(req); err != nil {
		utils.ValidationError(c, err)
		return
	}
	req.LoggedAt = normalizeLoggedAt(req.LoggedAt)

	day, ok := h.resolveDay(uid, req.LoggedOn, req.LoggedAt)
	if !ok {
		utils.Fail(c, utils.CodeInvalidLoggedOn, nil)
		return
	}
	log, err := h.s.Weight.Update(uid, lid, req, day)
	if err == sql.ErrNoRows {
		utils.Fail(c, utils.CodeEntryNotFound, nil)
		return
	}
	if utils.DBError(c, err) {
		return
	}
	utils.OK(c, log)
}

func (h *Handler) DeleteWeightLog(c *gin.Context) {
	uid := middleware.UserID(c)
	lid, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		utils.Fail(c, utils.CodeInvalidID, nil)
		return
	}
	n, err := h.s.Weight.Delete(uid, lid)
	if utils.DBError(c, err) {
		return
	}
	if n == 0 {
		utils.Fail(c, utils.CodeEntryNotFound, nil)
		return
	}
	utils.OK(c, gin.H{"deleted": true})
}

func (h *Handler) GetWeightStats(c *gin.Context) {
	uid := middleware.UserID(c)
	stats, err := h.s.Weight.Stats(uid, h.daysAgoDay(uid, 7), h.daysAgoDay(uid, 30))
	if utils.DBError(c, err) {
		return
	}
	utils.OK(c, gin.H{
		"latest":        stats.Latest,
		"starting":      stats.Starting,
		"min":           stats.Min,
		"max":           stats.Max,
		"avg":           stats.Avg,
		"total_entries": stats.TotalEntries,
		"change_7d":     stats.Change7d,
		"change_30d":    stats.Change30d,
	})
}

// normalizeLoggedAt defaults a zero time to now and forces UTC: keeps the wire
// format consistent across deployments and lets a client-supplied offset
// timestamp round-trip cleanly (a non-UTC time.Time otherwise fails to scan back).
func normalizeLoggedAt(t time.Time) time.Time {
	if t.IsZero() {
		t = time.Now()
	}
	return t.UTC()
}