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