} return p, nil if input.Direction == "up" { func StartWorkoutFromRoutine(db *sqlx.DB, userID uuid.UUID, routineID uuid.UUID) (Workout, error) { func GetAllRoutines(db *sqlx.DB, userID uuid.UUID) ([]Routine, error) { ID uuid.UUID `db:"id" json:"id"` db.Select(&stats, query, userID, exerciseID) TotalSetsThisMonth int `json:"totalSetsThisMonth"` DB *sqlx.DB SELECT family_id FROM families_users WHERE user_id = $1 lowestMap := make(map[itemKey]lowestRow, len(lowest)) return nil defer func() { _ = tx.Rollback() }() } limit int var userID uuid.UUID Name string `json:"name" db:"name"` for _, re := range exercises { } type ScannedItem struct { mu sync.Mutex var entries []WorkoutCalendarEntry LatestPrice: l.Price, LatestStore: l.Store, Interval int `db:"interval" json:"interval"` LatestStore *string `json:"latestStore" db:"latest_store"` ID uuid.UUID `db:"id" json:"id"` FailureExercises []ExerciseCount `json:"failureExercises"` qy := `INSERT INTO users (email, created_at) VALUES ($1, $2) RETURNING id` for _, t := range timestamps { }) } return w, nil if !isMuted { IsPromo bool `json:"isPromo" db:"is_promo"` func LogPrice(ctx context.Context, db *sqlx.DB, p MarketPrice) (UpsertResult, error) { updated_at = NOW() WHERE id = :id` mux.HandleFunc("POST /trackers", s.RequireAuthentication(s.NewHandler)) type Service struct { TaskLookAheadDays int `db:"task_lookahead_days" json:"taskLookaheadDays"` } } }) Owner uuid.UUID `json:"-" db:"owner_id"` if slices.Contains(s.AllowedOrigins, origin) { } AllowedOrigins []string Partitioned: partitioned, MaxAge: 5 * 60, ID uuid.UUID `db:"id" json:"id"` var workouts []Workout return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { try { NewFamily(db, f) args = append(args, filter.Category) db.Exec(q, w.StartTime, w.Notes, workoutID, userID) w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS") tx, err := db.Beginx() func New(db *sqlx.DB, t Tracker) (uuid.UUID, error) { Domain string var newE Entry case "day": Icon string `json:"icon" db:"icon"` return summary, nil workouts[i].Sets = []Set{} WHERE user_id = $1 AND start_time >= date_trunc('month', NOW())` return corsMiddleware(authMiddleware(mux)) return nil lowest, err := getLowestPrices(db, userID, category) LowestPrice: low.Price, LowestStore: low.Store, FamilyID uuid.UUID `json:"-" db:"family_id"` ctx := context.WithValue(r.Context(), logging.RequestIDKey, u.String()) } if err != nil { } db.Select(&workouts, q, userID) for _, r := range lowest { lowestMap[makeKey(r.ItemName, r.Country)] = r } err := db.QueryRow(q, e.TrackerID, e.Interval). } q := `SELECT mp.* FROM market_prices mp } func GetExerciseStats(db *sqlx.DB, userID uuid.UUID, exerciseID string) ([]ExerciseSetStats, error) { COUNT(gs.id) as set_count, LastInterval *int `json:"lastInterval" db:"last_interval"` credentials: "include", err := db.QueryRow(q, email).Scan(&userID) TotalWorkoutsThisMonth int `json:"totalWorkoutsThisMonth"` SoundModeProfile string `db:"sound_mode_profile" json:"soundModeProfile"` var current Routine } } FROM gym_sets gs JOIN gym_workouts gw ON gs.workout_id = gw.id valid = append(valid, t) request.headers.set("Cookie", cookieString) return nil } } next.ServeHTTP(w, r.WithContext(ctx)) var newID uuid.UUID } catch (err) { pinned = :pinned, show = :show, icon = :icon, var neighbor Routine } SyncUserInternal(db *sqlx.DB, email string, createdAt time.Time) (bool, uuid.UUID, error) WHERE gw.user_id = $1 GROUP BY gw.id ORDER BY gw.start_time DESC` Sets []Set `db:"-" json:"sets"` input.ItemName = strings.TrimSpace(input.ItemName) tx.Commit() if r.Method == http.MethodOptions { w.WriteHeader(http.StatusOK); return } Path: s.CookieConfig.Path, Domain: domain, var input tracker.Input Quantity *float64 `json:"quantity,omitempty"` console.error("Network error:", err) if rows.Next() { rows.Scan(&newID) } return nil Partitioned bool if err == nil { return false, userID, nil } return entries, nil Owner: userID, Family: familyID, insights = append(insights, MarketInsight{ func GetInsights(db *sqlx.DB, userID uuid.UUID, category string) ([]MarketInsight, error) { return fmt.Errorf("delete tracker: %w", err) return w, nil } Pinned bool `json:"pinned" db:"pinned"` userID, err := s.GetUserIDFromContext(r.Context()) } LastEntry *time.Time `db:"last_entry" json:"lastEntry"` Secure: secure, SameSite: sameSite, IsMuted bool `json:"isMuted" db:"is_muted"` familyID, _ := user.GetUserFamilyID(s.DB, userID) ID uuid.UUID `db:"id" json:"id"` return new Response(null, { status: 503 }) interval = :interval, interval_unit = :interval_unit, category, kind, action_label, pinned, show, icon } TrackerID uuid.UUID `db:"tracker_id" json:"trackerId"` } type Routine struct { routines[i].Exercises = []RoutineExercise{} } Category *string `json:"category" db:"category"` var s Set const cookieString = Object.entries(cookies) COUNT(DISTINCT gs.exercise_id) as exercise_count, return fmt.Errorf("edit tracker: %w", err) db.QueryRow(volumeQ, userID).Scan(&summary.TotalVolumeThisMonth, &summary.TotalSetsThisMonth) return newT, nil q = `INSERT INTO tracker_user_settings (tracker_id, user_id, is_muted) VALUES ($1, $2, TRUE) } return nil } w.Sets = append(w.Sets, s) type RateLimiter struct { mux.HandleFunc("GET /health", Healthcheck) return await fetch(input, init) ids[i] = w.ID } Secure bool LatestPrice float64 `json:"latestPrice" db:"latest_price"` func Create(db *sqlx.DB, e Entry) (Entry, error) { defer tx.Rollback() Reps *int16 `db:"reps" json:"reps"` func MuteTracker(db *sqlx.DB, trackerID uuid.UUID, userID uuid.UUID, isMuted bool) error { return result, fmt.Errorf("commit: %w", err) func NewWorkout(db *sqlx.DB, userID uuid.UUID) (Workout, error) { rows, err := db.NamedQuery(q, t) ids[i] = r.ID :owner_id, :family_id, :name, :display, :interval, } Quantity *float64 `json:"quantity" db:"quantity"` }) defer rl.mu.Unlock() w.Header().Set("Access-Control-Allow-Credentials", "true") TopExercises []ExerciseCount `json:"topExercises"` WeightKg *float64 `db:"weight_kg" json:"weightKg"` SoundModeQuick string `db:"sound_mode_quick" json:"soundModeQuick"` return t, nil case "year": Position int16 `db:"position" json:"position"` func EditWorkout(db *sqlx.DB, userID uuid.UUID, workoutID uuid.UUID, w WorkoutInput) error { func (s *Service) setSessionCookies(w http.ResponseWriter, r *http.Request, jwt string, token string) { if err != nil { return newID, fmt.Errorf("new tracker: %w", err) } Store *string `json:"store" db:"store"` } ) RETURNING id` for i := range tDB { Exercises []RoutineExercise `db:"-" json:"exercises"` err := db.QueryRow(q, userID).Scan( func RequestIDMiddleware(next http.Handler) http.Handler { } } } } q := `INSERT INTO entries (tracker_id, interval) } LastIntervalUnit *string `json:"lastIntervalUnit" db:"last_interval_unit"` } tx.Select(&exercises, eq, routineID, userID) ON tus.user_id = $1 AND tus.tracker_id = t.id &w.ID, &w.UserID, &w.StartTime, db.Exec(q, isPinned, trackerID, userID) :category, :kind, :action_label, :pinned, :show, :icon return newID, nil insights := make([]MarketInsight, 0, len(latest)) MaxAge: 24 * 30 * 60 * 60, query := `SELECT gw.start_time::date as date, gs.weight_kg, gs.reps, gs.set_type return workouts, nil throwHttpErrors: false, ARRAY_AGG(DISTINCT gs.exercise_id) as exercise_ids switch tDB[i].IntervalUnit { LowestStore *string `json:"lowestStore" db:"lowest_store"` q := `SELECT * FROM gym_workouts q := `UPDATE gym_workouts SET start_time = $1, notes = $2, updated_at = NOW() tx, err := db.Beginx() WHERE gw.user_id = $1 AND LOWER(gs.exercise_id) = LOWER($2) .map(([key, value]) => `${key}=${value}`) for i, w := range workouts { return nil, fmt.Errorf("select trackers: %w", err) ) VALUES ( } }) ItemName: l.ItemName, Category: l.Category, return newE, err var stats []ExerciseSetStats swapQ := `UPDATE gym_routines SET position = $1::smallint WHERE id = $2` Price float64 `json:"price"` Tracker func UpdateName(db *sqlx.DB, userID uuid.UUID, name string) error { } pos++ response.RespondWithError(w, http.StatusUnauthorized, "unauthorized") } } prefix: apiUrl, ItemName string `json:"itemName"` db.Exec(swapQ, neighbor.Position, current.ID) case "month": ItemName string `json:"itemName" db:"item_name"` PerformedAt time.Time `db:"performed_at" json:"performedAt"` func (UserManager) SyncUserInternal(db *sqlx.DB, email string, createdAt time.Time) (bool, uuid.UUID, error) { } q := `SELECT t.*, f.name AS family_name FROM trackers t mux.HandleFunc("GET /trackers", s.RequireAuthentication(s.GetAllHandler)) p.ItemName = canonicalizeItemName(ctx, db, p.FamilyID, p.ItemName) ) ORDER BY t.pinned DESC, t.name ASC` Client *stytchapi.API ExerciseID string `db:"exercise_id" json:"exerciseId"` func GetSummary(db *sqlx.DB, userID uuid.UUID) (WorkoutSummary, error) { } return nil WHERE family_id = $1 AND LOWER(item_name) = LOWER($2) q := `UPDATE users SET name = $1 WHERE id = $2` WHERE t.owner_id = $1 OR t.family_id IN ( low := lowestMap[makeKey(l.ItemName, l.Country)] workoutsQ := `SELECT COUNT(*) FROM gym_workouts Category *string `json:"category" db:"category"` q := `DELETE FROM trackers WHERE id = $1 AND owner_id = $2` WorkoutID uuid.UUID `db:"workout_id" json:"workoutId"` } } if err := db.Select(&t, q, userID); err != nil { err = tx.Get(&existingID, checkQ, p.FamilyID, p.ItemName, p.Price) } cutoff := now.Add(-rl.window) } Category *string `json:"category,omitempty"` Name: input.Name, Kind: input.Kind, ON CONFLICT (tracker_id, user_id) DO UPDATE SET is_muted = TRUE` VALUES ($1) RETURNING *` .join("; ") ) func CalculateTrackersLastDue(tDB []LatestEntry) ([]LatestEntry, error) { if err := tx.Commit(); err != nil { SELECT family_id FROM families_users WHERE user_id = $1 LEFT JOIN tracker_user_settings tus db.Exec(q, trackerID, userID) u, _ := uuid.NewV7() return stats, nil p.ItemName = titleCase(p.ItemName) Name string `db:"name" json:"name"` db.Get(&summary.TotalWorkoutsThisMonth, workoutsQ, userID) if t.After(cutoff) { Category string `json:"category" db:"category"` db.Select(&entries, calendarQ, userID) WHERE mp.family_id IN ( if (Capacitor.getPlatform() === "android") { WHERE id = $3 AND user_id = $4` } w.Sets = []Set{} func Delete(db *sqlx.DB, trackerID uuid.UUID, userID uuid.UUID) error { ids := make([]uuid.UUID, len(workouts)) Get(db *sqlx.DB, email string) (user.User, error) IsPromo bool `json:"isPromo"` origin := r.Header.Get("Origin") WHERE user_id = $1 ORDER BY start_time DESC` } Scan(&newE.ID, &newE.TrackerID) mux := http.NewServeMux() mux.HandleFunc("/authenticate", s.MagicLinkHandler) tx.QueryRow(setQ, w.ID, re.ExerciseID, lu.WeightKg, lu.Reps, setType, pos).Scan(&s) FROM gym_workouts gw LEFT JOIN gym_sets gs ON gs.workout_id = gw.id export const api = ky.create({ db.Exec(q, name, userID) type User struct { type UserManager interface { w.Header().Set("X-Request-ID", u.String()) Path string const cookies = await CapacitorCookies.getCookies({ url: cookieUrl }) q := `SELECT id FROM users WHERE email=$1` db.Select(&routines, rq, userID) entries map[string][]time.Time LatestDate time.Time `json:"latestDate" db:"latest_date"` SameSite http.SameSite UpdatedAt time.Time `db:"updated_at" json:"updatedAt"` VALUES ($1, $2) RETURNING *` json.NewDecoder(r.Body).Decode(&input) Price float64 `json:"price" db:"price"` Interval int `json:"interval" db:"interval"` var t []Tracker UserID uuid.UUID `db:"user_id" json:"userId"` UserID uuid.UUID `db:"user_id" json:"userId"` rMap[r.ID] = i http.SetCookie(w, &http.Cookie{ func (rl *RateLimiter) Allow(key string) bool { } checkQ := `SELECT id FROM market_prices wq := `INSERT INTO gym_workouts (user_id) VALUES ($1) RETURNING *` threshold = tDB[i].LastEntry.Add(time.Duration(*itv) * 24 * time.Hour) ORDER BY position ASC LIMIT 1` return result, nil type WorkoutSummary struct { func Edit(db *sqlx.DB, t Tracker) error { } var input market.Input f := Family{Name: "Family", OwnerID: userID} } owner_id, family_id, name, display, interval, }) if isMuted { defer rows.Close() func NewHTTPHandler(s *server.Service) http.Handler { } q = `DELETE FROM tracker_user_settings WHERE tracker_id = $1 AND user_id = $2` ScanLimiter *RateLimiter ID uuid.UUID `json:"id" db:"id"` func TogglePin(db *sqlx.DB, userID uuid.UUID, trackerID uuid.UUID, isPinned bool) error { ids := make([]uuid.UUID, len(routines)) WHERE gw.user_id = $1 AND gs.weight_kg IS NOT NULL` TotalVolumeThisMonth float64 `json:"totalVolumeThisMonth"` db.Get(&current, `SELECT * FROM gym_routines WHERE id = $1 AND user_id = $2`, input.RoutineID, userID) mux.HandleFunc("GET /vacations", s.RequireAuthentication(s.GetVacationsHandler)) Email string `db:"email" json:"email"` type Tracker struct { } nq = `SELECT * FROM gym_routines WHERE user_id = $1 AND position > $2 func ReorderRoutine(db *sqlx.DB, userID uuid.UUID, input ReorderRoutineInput) error { Notes *string `db:"notes" json:"notes"` return len(valid) < rl.limit HttpOnly: s.CookieConfig.HTTPOnly, } DueStatus *string `json:"dueStatus" db:"-"` func GetCalendarWorkouts(db *sqlx.DB, userID uuid.UUID) ([]WorkoutCalendarEntry, error) { UNION SELECT id FROM families WHERE owner_id = $1 return return routines, nil rq := `SELECT * FROM gym_routines w.Sets = []Set{} w.Header().Set("Access-Control-Allow-Origin", origin) } StartDate *time.Time `json:"startDate,omitempty" db:"start_date"` AND price = $3 AND DATE(created_at) = CURRENT_DATE LIMIT 1` } WHERE gr.id = $1 AND gr.user_id = $2 ORDER BY gre.position ASC` func (s *Service) NewHandler(w http.ResponseWriter, r *http.Request) { type CookieConfig struct { } ORDER BY gw.start_time ASC, gs.position ASC` for range re.Sets { } WHERE user_id = $1 ORDER BY position ASC, created_at ASC` type Set struct { )` }) threshold = tDB[i].LastEntry.AddDate(0, int(*itv), 0) StartTime time.Time `db:"start_time" json:"startTime"` type LatestEntry struct { JOIN families f ON t.family_id = f.id for _, l := range latest { q += ` ORDER BY mp.created_at DESC` ID uuid.UUID `json:"id" db:"id"` rl.mu.Lock() func (s *Service) LogMarketPriceHandler(w http.ResponseWriter, r *http.Request) { q += fmt.Sprintf(` AND LOWER(mp.category) = LOWER($%d)`, len(args)) if filter.Category != "" { LowestDate time.Time `json:"lowestDate" db:"lowest_date"` Display string `json:"display" db:"display"` HTTPOnly bool return nil SetType string `db:"set_type" json:"setType"` var routines []Routine Position int16 `db:"position" json:"position"` json.NewDecoder(r.Body).Decode(&input) db.Exec(swapQ, current.Position, neighbor.ID) GetInternalUserID(db *sqlx.DB, email string) (uuid.UUID, error) rMap := make(map[uuid.UUID]int, len(routines)) } latest, err := getLatestPrices(db, userID, category) func GetPrices(db *sqlx.DB, userID uuid.UUID, filter PriceFilter) ([]MarketPrice, error) { category = :category, kind = :kind, IsCompleted bool `db:"is_completed" json:"isCompleted"` func CORSMiddleware(s *server.Service, next http.Handler) http.Handler { var exercises []RoutineExercise tx.QueryRow(wq, userID).Scan(&w.ID, &w.UserID, &w.StartTime, &w.Notes) return true, userID, nil Cost *float64 `json:"cost,omitempty" db:"cost"` window time.Duration eq := `SELECT gre.* FROM gym_routine_exercises gre type MarketInsight struct { q := `INSERT INTO gym_workouts (user_id) t := tracker.Tracker{ } else { JOIN gym_routines gr ON gre.routine_id = gr.id FROM gym_sets gs JOIN gym_workouts gw ON gs.workout_id = gw.id valid := timestamps[:0] ItemName string `json:"itemName" db:"item_name"` type Workout struct { func GetAllWorkouts(db *sqlx.DB, userID uuid.UUID) ([]Workout, error) { start_date = :start_date, cost = :cost, userID, _ := s.GetUserIDFromContext(r.Context()) nq = `SELECT * FROM gym_routines WHERE user_id = $1 AND position < $2 Name *string `db:"name" json:"name"` now := time.Now() next.ServeHTTP(w, r) type Entry struct { calendarQ := `SELECT gw.id as workout_id, gw.start_time, const safeFetch: typeof fetch = async (input, init) => { q := `INSERT INTO trackers ( Unit *string `json:"unit" db:"unit"` CreatedAt time.Time `db:"created_at" json:"createdAt"` Notifier *notifier.FCMClient IntervalUnit string `json:"intervalUnit" db:"interval_unit"` LoggedBy *uuid.UUID `json:"loggedBy" db:"logged_by"` ID uuid.UUID `db:"id" json:"id"` if time.Now().After(threshold) { n := "due"; newT[i].DueStatus = &n } q := `UPDATE trackers SET pinned = $1 WHERE id = $2 AND owner_id = $3` var w Workout if _, err := db.NamedExec(q, t); err != nil { Name: "stytch_session_jwt", Value: jwt, } return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { return insights, nil } http.SetCookie(w, &http.Cookie{ } Show bool `json:"show" db:"show"` } } } fetch: safeFetch, } Kind string `json:"kind" db:"kind"` LowestPrice float64 `json:"lowestPrice" db:"lowest_price"` Family uuid.UUID `json:"familyId" db:"family_id"` } db.QueryRow(qy, email, createdAt).Scan(&userID) threshold = tDB[i].LastEntry.AddDate(int(*itv), 0, 0) } func GetAll(db *sqlx.DB, userID uuid.UUID) ([]Tracker, error) { ORDER BY position DESC LIMIT 1` type MarketPrice struct { var w Workout Name: "stytch_session_token", Value: token, volumeQ := `SELECT COALESCE(SUM(gs.weight_kg * gs.reps), 0), COUNT(*) if _, err := db.Exec(q, trackerID, userID); err != nil { PreferredCharacter string `db:"preferred_character" json:"preferredCharacter"` for i, r := range routines { w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization") } q := `UPDATE trackers SET name = :name, display = :display, } if err != sql.ErrNoRows { return false, userID, fmt.Errorf("fetch user: %w", err) } } if err != nil { return result, fmt.Errorf("begin tx: %w", err) }