web-app-template/service/workout.go

package service

import (
	"log/slog"
	"me-fit/template"
	"me-fit/template/workout"
	"me-fit/types"
	"me-fit/utils"

	"database/sql"
	"net/http"
	"strconv"
	"time"
)

func HandleWorkoutPage(db *sql.DB, serverSettings *types.ServerSettings) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		user := utils.GetUser(r)
		if user == nil {
			utils.DoRedirect(w, r, "/auth/signin")
			return
		}

		currentDate := time.Now().Format("2006-01-02")
		inner := workout.WorkoutComp(currentDate)
		userComp := UserInfoComp(user)
		err := template.Layout(inner, userComp, serverSettings.Environment).Render(r.Context(), w)
		if err != nil {
			utils.LogError("Failed to render workout page", err)
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		}
	}
}

func HandleWorkoutNewComp(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		user := utils.GetUser(r)
		if user == nil {
			utils.DoRedirect(w, r, "/auth/signin")
			return
		}

		var dateStr = r.FormValue("date")
		var typeStr = r.FormValue("type")
		var setsStr = r.FormValue("sets")
		var repsStr = r.FormValue("reps")

		if dateStr == "" || typeStr == "" || setsStr == "" || repsStr == "" {
			utils.TriggerToast(w, r, "error", "Missing required fields")
			http.Error(w, "Missing required fields", http.StatusBadRequest)
			return
		}

		date, err := time.Parse("2006-01-02", dateStr)
		if err != nil {
			utils.TriggerToast(w, r, "error", "Invalid date")
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		sets, err := strconv.Atoi(setsStr)
		if err != nil {
			utils.TriggerToast(w, r, "error", "Invalid number")
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		reps, err := strconv.Atoi(repsStr)
		if err != nil {
			utils.TriggerToast(w, r, "error", "Invalid number")
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}

		var rowId int
		err = db.QueryRow("INSERT INTO workout (user_id, date, type, sets, reps) VALUES (?, ?, ?, ?, ?) RETURNING rowid", user.Id, date, typeStr, sets, reps).Scan(&rowId)
		if err != nil {
			utils.LogError("Could not insert workout", err)
			utils.TriggerToast(w, r, "error", "Internal Server Error")
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		wo := workout.Workout{
			Id:   strconv.Itoa(rowId),
			Date: renderDate(date),
			Type: r.FormValue("type"),
			Sets: r.FormValue("sets"),
			Reps: r.FormValue("reps"),
		}

		err = workout.WorkoutItemComp(wo, true).Render(r.Context(), w)
		if err != nil {
			utils.LogError("Could not render workoutitem", err)
			utils.TriggerToast(w, r, "error", "Internal Server Error")
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	}
}

func HandleWorkoutGetComp(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		user := utils.GetUser(r)
		if user == nil {
			utils.DoRedirect(w, r, "/auth/signin")
			return
		}

		rows, err := db.Query("SELECT rowid, date, type, sets, reps FROM workout WHERE user_id = ? ORDER BY date desc", user.Id)
		if err != nil {
			utils.LogError("Could not get workouts", err)
			utils.TriggerToast(w, r, "error", "Internal Server Error")
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		var workouts = make([]workout.Workout, 0)
		for rows.Next() {
			var workout workout.Workout

			err = rows.Scan(&workout.Id, &workout.Date, &workout.Type, &workout.Sets, &workout.Reps)
			if err != nil {
				utils.LogError("Could not scan workout", err)
				utils.TriggerToast(w, r, "error", "Internal Server Error")
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			workout.Date, err = renderDateStr(workout.Date)
			if err != nil {
				utils.LogError("Could not render date", err)
				utils.TriggerToast(w, r, "error", "Internal Server Error")
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			workouts = append(workouts, workout)
		}

		workout.WorkoutListComp(workouts).Render(r.Context(), w)
	}
}

func HandleWorkoutDeleteComp(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		user := utils.GetUser(r)
		if user == nil {
			utils.DoRedirect(w, r, "/auth/signin")
			return
		}

		rowId := r.PathValue("id")
		if rowId == "" {
			http.Error(w, "Missing required fields", http.StatusBadRequest)
			slog.Warn("Missing required fields for workout delete")
			utils.TriggerToast(w, r, "error", "Missing ID field")
			return
		}

		res, err := db.Exec("DELETE FROM workout WHERE user_id = ? AND rowid = ?", user.Id, rowId)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			utils.LogError("Could not delete workout", err)
			utils.TriggerToast(w, r, "error", "Internal Server Error")
			return
		}

		rows, err := res.RowsAffected()
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			utils.LogError("Could not get rows affected", err)
			utils.TriggerToast(w, r, "error", "Internal Server Error")
			return
		}

		if rows == 0 {
			http.Error(w, "Not found", http.StatusNotFound)
			slog.Warn("Could not find workout to delete")
			utils.TriggerToast(w, r, "error", "Not found. Refresh the page.")
			return
		}
	}
}

func renderDateStr(date string) (string, error) {
	t, err := time.Parse("2006-01-02 15:04:05-07:00", date)
	if err != nil {
		return "", err
	}

	return renderDate(t), nil
}

func renderDate(date time.Time) string {
	return date.Format("2006-01-02")
}