Ty Clifford
1363 lines
50 KiB
PHP
1363 lines
50 KiB
PHP
<?php
|
|
declare(strict_types=1);
|
|
|
|
date_default_timezone_set('America/New_York');
|
|
|
|
const APP_ROOT = __DIR__ . '/..';
|
|
const DATA_DIR = APP_ROOT . '/data';
|
|
const DB_PATH = DATA_DIR . '/health_tracker.sqlite';
|
|
|
|
function app_db(): PDO
|
|
{
|
|
static $pdo = null;
|
|
|
|
if ($pdo instanceof PDO) {
|
|
return $pdo;
|
|
}
|
|
|
|
if (!is_dir(DATA_DIR)) {
|
|
mkdir(DATA_DIR, 0775, true);
|
|
}
|
|
|
|
$pdo = new PDO('sqlite:' . DB_PATH);
|
|
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
|
$pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
|
|
$pdo->exec('PRAGMA foreign_keys = ON');
|
|
|
|
app_init_db($pdo);
|
|
|
|
return $pdo;
|
|
}
|
|
|
|
function app_init_db(PDO $pdo): void
|
|
{
|
|
$pdo->exec(<<<SQL
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
name TEXT NOT NULL,
|
|
email TEXT DEFAULT '',
|
|
fitness_focus TEXT DEFAULT '',
|
|
role TEXT NOT NULL DEFAULT 'member',
|
|
status TEXT NOT NULL DEFAULT 'active',
|
|
phone TEXT DEFAULT '',
|
|
birthday TEXT DEFAULT '',
|
|
height_in REAL DEFAULT 0,
|
|
training_level TEXT DEFAULT '',
|
|
emergency_contact TEXT DEFAULT '',
|
|
theme_mode TEXT NOT NULL DEFAULT 'dark',
|
|
theme_accent TEXT NOT NULL DEFAULT 'green',
|
|
updated_at TEXT DEFAULT '',
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS exercises (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
|
|
name TEXT NOT NULL,
|
|
category TEXT NOT NULL,
|
|
muscle_group TEXT DEFAULT '',
|
|
default_unit TEXT DEFAULT '',
|
|
notes TEXT DEFAULT '',
|
|
is_builtin INTEGER NOT NULL DEFAULT 0,
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS supplements (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
|
|
name TEXT NOT NULL,
|
|
timing TEXT NOT NULL,
|
|
default_dose TEXT DEFAULT '',
|
|
purpose TEXT DEFAULT '',
|
|
notes TEXT DEFAULT '',
|
|
is_builtin INTEGER NOT NULL DEFAULT 0,
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS nutrition_goals (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
label TEXT NOT NULL,
|
|
scope TEXT NOT NULL CHECK (scope IN ('daily', 'weekly', 'monthly')),
|
|
calories REAL NOT NULL DEFAULT 0,
|
|
protein_g REAL NOT NULL DEFAULT 0,
|
|
carbs_g REAL NOT NULL DEFAULT 0,
|
|
fat_g REAL NOT NULL DEFAULT 0,
|
|
water_ml REAL NOT NULL DEFAULT 0,
|
|
start_date TEXT NOT NULL,
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS routines (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
nutrition_goal_id INTEGER REFERENCES nutrition_goals(id) ON DELETE SET NULL,
|
|
name TEXT NOT NULL,
|
|
workout_type TEXT NOT NULL,
|
|
planner_scope TEXT NOT NULL CHECK (planner_scope IN ('daily', 'weekly', 'monthly')),
|
|
start_date TEXT NOT NULL,
|
|
end_date TEXT DEFAULT '',
|
|
intensity TEXT DEFAULT '',
|
|
notes TEXT DEFAULT '',
|
|
active INTEGER NOT NULL DEFAULT 1,
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS workouts (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
routine_id INTEGER REFERENCES routines(id) ON DELETE SET NULL,
|
|
exercise_id INTEGER REFERENCES exercises(id) ON DELETE SET NULL,
|
|
scheduled_on TEXT NOT NULL,
|
|
title TEXT NOT NULL,
|
|
workout_type TEXT NOT NULL,
|
|
sets INTEGER DEFAULT 0,
|
|
reps INTEGER DEFAULT 0,
|
|
weight_lbs REAL DEFAULT 0,
|
|
duration_min REAL DEFAULT 0,
|
|
distance_mi REAL DEFAULT 0,
|
|
intensity TEXT DEFAULT '',
|
|
status TEXT NOT NULL DEFAULT 'planned' CHECK (status IN ('planned', 'complete', 'skipped')),
|
|
notes TEXT DEFAULT '',
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS nutrition_logs (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
logged_on TEXT NOT NULL,
|
|
calories REAL NOT NULL DEFAULT 0,
|
|
protein_g REAL NOT NULL DEFAULT 0,
|
|
carbs_g REAL NOT NULL DEFAULT 0,
|
|
fat_g REAL NOT NULL DEFAULT 0,
|
|
water_ml REAL NOT NULL DEFAULT 0,
|
|
notes TEXT DEFAULT '',
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS supplement_logs (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
supplement_id INTEGER REFERENCES supplements(id) ON DELETE SET NULL,
|
|
taken_on TEXT NOT NULL,
|
|
timing TEXT NOT NULL,
|
|
dose TEXT DEFAULT '',
|
|
status TEXT NOT NULL DEFAULT 'planned' CHECK (status IN ('planned', 'taken', 'skipped')),
|
|
notes TEXT DEFAULT '',
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS body_metrics (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
|
measured_on TEXT NOT NULL,
|
|
weight_lbs REAL DEFAULT 0,
|
|
body_fat_pct REAL DEFAULT 0,
|
|
sleep_hours REAL DEFAULT 0,
|
|
resting_hr INTEGER DEFAULT 0,
|
|
mood TEXT DEFAULT '',
|
|
notes TEXT DEFAULT '',
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_workouts_user_date ON workouts(user_id, scheduled_on);
|
|
CREATE INDEX IF NOT EXISTS idx_nutrition_logs_user_date ON nutrition_logs(user_id, logged_on);
|
|
CREATE INDEX IF NOT EXISTS idx_supplement_logs_user_date ON supplement_logs(user_id, taken_on);
|
|
CREATE INDEX IF NOT EXISTS idx_body_metrics_user_date ON body_metrics(user_id, measured_on);
|
|
SQL);
|
|
|
|
migrate_users_table($pdo);
|
|
seed_libraries($pdo);
|
|
seed_demo_data($pdo);
|
|
ensure_first_user_is_admin($pdo);
|
|
}
|
|
|
|
function migrate_users_table(PDO $pdo): void
|
|
{
|
|
$columns = db_table_columns($pdo, 'users');
|
|
$definitions = [
|
|
'role' => "TEXT NOT NULL DEFAULT 'member'",
|
|
'status' => "TEXT NOT NULL DEFAULT 'active'",
|
|
'phone' => "TEXT DEFAULT ''",
|
|
'birthday' => "TEXT DEFAULT ''",
|
|
'height_in' => "REAL DEFAULT 0",
|
|
'training_level' => "TEXT DEFAULT ''",
|
|
'emergency_contact' => "TEXT DEFAULT ''",
|
|
'updated_at' => "TEXT DEFAULT ''",
|
|
];
|
|
|
|
foreach ($definitions as $column => $definition) {
|
|
if (!in_array($column, $columns, true)) {
|
|
$pdo->exec("ALTER TABLE users ADD COLUMN {$column} {$definition}");
|
|
}
|
|
}
|
|
|
|
$pdo->exec("UPDATE users SET role = 'member' WHERE role IS NULL OR role = ''");
|
|
$pdo->exec("UPDATE users SET status = 'active' WHERE status IS NULL OR status = ''");
|
|
$pdo->exec("UPDATE users SET updated_at = created_at WHERE updated_at IS NULL OR updated_at = ''");
|
|
}
|
|
|
|
function db_table_columns(PDO $pdo, string $table): array
|
|
{
|
|
$rows = db_all($pdo, "PRAGMA table_info({$table})");
|
|
return array_map(static fn(array $row): string => $row['name'], $rows);
|
|
}
|
|
|
|
function ensure_first_user_is_admin(PDO $pdo): void
|
|
{
|
|
$firstUserId = (int) db_value($pdo, 'SELECT id FROM users ORDER BY id LIMIT 1');
|
|
if ($firstUserId <= 0) {
|
|
return;
|
|
}
|
|
|
|
$adminCount = (int) db_value($pdo, "SELECT COUNT(*) FROM users WHERE role = 'admin'");
|
|
if ($adminCount === 0) {
|
|
$stmt = $pdo->prepare("UPDATE users SET role = 'admin', status = 'active', updated_at = ? WHERE id = ?");
|
|
$stmt->execute([app_now(), $firstUserId]);
|
|
}
|
|
}
|
|
|
|
function seed_libraries(PDO $pdo): void
|
|
{
|
|
$exerciseCount = (int) $pdo->query("SELECT COUNT(*) FROM exercises WHERE is_builtin = 1")->fetchColumn();
|
|
if ($exerciseCount === 0) {
|
|
$exercises = [
|
|
['Barbell Back Squat', 'Weight lifting', 'Legs', 'sets x reps x lb'],
|
|
['Deadlift', 'Weight lifting', 'Posterior chain', 'sets x reps x lb'],
|
|
['Bench Press', 'Weight lifting', 'Chest', 'sets x reps x lb'],
|
|
['Overhead Press', 'Weight lifting', 'Shoulders', 'sets x reps x lb'],
|
|
['Pull-Up', 'Weight lifting', 'Back', 'sets x reps'],
|
|
['Bent-Over Row', 'Weight lifting', 'Back', 'sets x reps x lb'],
|
|
['Romanian Deadlift', 'Weight lifting', 'Hamstrings', 'sets x reps x lb'],
|
|
['Walking Lunge', 'Weight lifting', 'Legs', 'sets x reps'],
|
|
['Hip Thrust', 'Weight lifting', 'Glutes', 'sets x reps x lb'],
|
|
['Biceps Curl', 'Weight lifting', 'Arms', 'sets x reps x lb'],
|
|
['Triceps Dip', 'Weight lifting', 'Arms', 'sets x reps'],
|
|
['Core Plank', 'Core', 'Core', 'minutes'],
|
|
['Kettlebell Swing', 'Conditioning', 'Full body', 'sets x reps'],
|
|
['HIIT Circuit', 'Conditioning', 'Full body', 'minutes'],
|
|
['Indoor Cycling', 'Cycling', 'Cardio', 'minutes + miles'],
|
|
['Road Ride', 'Cycling', 'Cardio', 'minutes + miles'],
|
|
['Easy Run', 'Running', 'Cardio', 'minutes + miles'],
|
|
['Tempo Run', 'Running', 'Cardio', 'minutes + miles'],
|
|
['Sprint Intervals', 'Running', 'Cardio', 'rounds + minutes'],
|
|
['Pool Laps', 'Swimming', 'Cardio', 'minutes + distance'],
|
|
['Open-Water Swim', 'Swimming', 'Cardio', 'minutes + distance'],
|
|
['Rowing Machine', 'Conditioning', 'Cardio', 'minutes + meters'],
|
|
['Yoga Mobility', 'Mobility', 'Recovery', 'minutes'],
|
|
['Hiking', 'Outdoor', 'Cardio', 'minutes + miles'],
|
|
['Jump Rope', 'Conditioning', 'Cardio', 'minutes'],
|
|
['Elliptical', 'Conditioning', 'Cardio', 'minutes'],
|
|
];
|
|
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO exercises (name, category, muscle_group, default_unit, notes, is_builtin, created_at)
|
|
VALUES (?, ?, ?, ?, '', 1, ?)"
|
|
);
|
|
foreach ($exercises as $exercise) {
|
|
$stmt->execute([...$exercise, app_now()]);
|
|
}
|
|
}
|
|
|
|
$supplementCount = (int) $pdo->query("SELECT COUNT(*) FROM supplements WHERE is_builtin = 1")->fetchColumn();
|
|
if ($supplementCount === 0) {
|
|
$supplements = [
|
|
['Pre-Workout Blend', 'Pre-workout', '1 scoop', 'Energy and focus'],
|
|
['Caffeine', 'Pre-workout', '100-200 mg', 'Alertness'],
|
|
['Creatine Monohydrate', 'Daily', '5 g', 'Strength and power output'],
|
|
['Beta-Alanine', 'Pre-workout', '3.2 g', 'High-intensity endurance'],
|
|
['Citrulline Malate', 'Pre-workout', '6-8 g', 'Pump and blood flow'],
|
|
['Electrolytes', 'Intra-workout', '1 serving', 'Hydration support'],
|
|
['BCAAs / EAAs', 'Intra-workout', '1 serving', 'Amino acid support'],
|
|
['Carb Powder', 'Intra-workout', '25-50 g', 'Training fuel'],
|
|
['Whey Protein', 'Post-workout', '25-35 g', 'Protein target support'],
|
|
['Casein Protein', 'Evening', '25-35 g', 'Slow-digesting protein'],
|
|
['Collagen Peptides', 'Daily', '10-20 g', 'Tendon and joint support'],
|
|
['Fish Oil / Omega-3', 'Daily', '1-2 g EPA/DHA', 'General health'],
|
|
['Magnesium Glycinate', 'Evening', '200-400 mg', 'Relaxation and sleep'],
|
|
['Vitamin D3', 'Daily', '1000-2000 IU', 'General health'],
|
|
['Multivitamin', 'Daily', '1 serving', 'Micronutrient coverage'],
|
|
['Tart Cherry', 'Post-workout', '1 serving', 'Recovery support'],
|
|
['Greens Powder', 'Daily', '1 serving', 'Micronutrient support'],
|
|
];
|
|
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO supplements (name, timing, default_dose, purpose, notes, is_builtin, created_at)
|
|
VALUES (?, ?, ?, ?, '', 1, ?)"
|
|
);
|
|
foreach ($supplements as $supplement) {
|
|
$stmt->execute([...$supplement, app_now()]);
|
|
}
|
|
}
|
|
}
|
|
|
|
function seed_demo_data(PDO $pdo): void
|
|
{
|
|
$userCount = (int) $pdo->query('SELECT COUNT(*) FROM users')->fetchColumn();
|
|
if ($userCount > 0) {
|
|
return;
|
|
}
|
|
|
|
$created = app_now();
|
|
$today = new DateTimeImmutable('today');
|
|
$weekStart = $today->modify('monday this week');
|
|
$monthStart = $today->modify('first day of this month');
|
|
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO users
|
|
(name, email, fitness_focus, role, status, phone, birthday, height_in, training_level,
|
|
emergency_contact, theme_mode, theme_accent, updated_at, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$stmt->execute([
|
|
'Alex Rivera',
|
|
'alex@example.test',
|
|
'Strength, cycling, and lean muscle',
|
|
'admin',
|
|
'active',
|
|
'',
|
|
'',
|
|
70,
|
|
'Intermediate',
|
|
'',
|
|
'dark',
|
|
'green',
|
|
$created,
|
|
$created,
|
|
]);
|
|
$alexId = (int) $pdo->lastInsertId();
|
|
$stmt->execute([
|
|
'Maya Chen',
|
|
'maya@example.test',
|
|
'Running base, swimming, and recovery',
|
|
'member',
|
|
'active',
|
|
'',
|
|
'',
|
|
64,
|
|
'Advanced',
|
|
'',
|
|
'dark',
|
|
'pink',
|
|
$created,
|
|
$created,
|
|
]);
|
|
$mayaId = (int) $pdo->lastInsertId();
|
|
|
|
$goalStmt = $pdo->prepare(
|
|
"INSERT INTO nutrition_goals
|
|
(user_id, label, scope, calories, protein_g, carbs_g, fat_g, water_ml, start_date, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$goals = [
|
|
[$alexId, 'Lean bulk day', 'daily', 2900, 190, 330, 85, 3600, app_date($weekStart)],
|
|
[$alexId, 'Lean bulk week', 'weekly', 20300, 1330, 2310, 595, 25200, app_date($weekStart)],
|
|
[$alexId, 'Monthly build', 'monthly', 87000, 5700, 9900, 2550, 108000, app_date($monthStart)],
|
|
[$mayaId, 'Endurance day', 'daily', 2350, 135, 310, 65, 3200, app_date($weekStart)],
|
|
[$mayaId, 'Endurance week', 'weekly', 16450, 945, 2170, 455, 22400, app_date($weekStart)],
|
|
];
|
|
foreach ($goals as $goal) {
|
|
$goalStmt->execute([...$goal, $created]);
|
|
}
|
|
|
|
$alexGoalId = (int) db_value($pdo, "SELECT id FROM nutrition_goals WHERE user_id = ? AND scope = 'weekly' LIMIT 1", [$alexId]);
|
|
$mayaGoalId = (int) db_value($pdo, "SELECT id FROM nutrition_goals WHERE user_id = ? AND scope = 'weekly' LIMIT 1", [$mayaId]);
|
|
|
|
$routineStmt = $pdo->prepare(
|
|
"INSERT INTO routines
|
|
(user_id, nutrition_goal_id, name, workout_type, planner_scope, start_date, end_date, intensity, notes, active, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)"
|
|
);
|
|
$routineStmt->execute([$alexId, $alexGoalId, 'Push Pull Legs + Ride', 'Hybrid', 'weekly', app_date($weekStart), '', 'Moderate', 'Three lifting days with one cycling push.', $created]);
|
|
$alexRoutineId = (int) $pdo->lastInsertId();
|
|
$routineStmt->execute([$alexId, $alexGoalId, 'Monthly Strength Block', 'Weight lifting', 'monthly', app_date($monthStart), '', 'High', 'Progressive overload with deload flexibility.', $created]);
|
|
$routineStmt->execute([$mayaId, $mayaGoalId, '5K Base + Swim', 'Running', 'weekly', app_date($weekStart), '', 'Moderate', 'Aerobic run focus with low-impact swim.', $created]);
|
|
$mayaRoutineId = (int) $pdo->lastInsertId();
|
|
|
|
$exerciseIds = db_key_values($pdo, "SELECT name, id FROM exercises WHERE is_builtin = 1");
|
|
$workoutStmt = $pdo->prepare(
|
|
"INSERT INTO workouts
|
|
(user_id, routine_id, exercise_id, scheduled_on, title, workout_type, sets, reps, weight_lbs,
|
|
duration_min, distance_mi, intensity, status, notes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$workouts = [
|
|
[$alexId, $alexRoutineId, $exerciseIds['Bench Press'], app_date($weekStart), 'Push strength', 'Weight lifting', 4, 6, 185, 55, 0, 'RPE 8', 'complete', 'Add 5 lb if bar speed holds.'],
|
|
[$alexId, $alexRoutineId, $exerciseIds['Indoor Cycling'], app_date($weekStart->modify('+1 day')), 'Zone 2 ride', 'Cycling', 0, 0, 0, 45, 14, 'Easy', 'planned', 'Keep nasal breathing.'],
|
|
[$alexId, $alexRoutineId, $exerciseIds['Deadlift'], app_date($weekStart->modify('+2 days')), 'Pull strength', 'Weight lifting', 5, 3, 315, 60, 0, 'Heavy', 'planned', 'Long rest between sets.'],
|
|
[$alexId, $alexRoutineId, $exerciseIds['Barbell Back Squat'], app_date($weekStart->modify('+4 days')), 'Legs volume', 'Weight lifting', 4, 8, 225, 65, 0, 'Moderate', 'planned', 'Superset core plank.'],
|
|
[$mayaId, $mayaRoutineId, $exerciseIds['Easy Run'], app_date($weekStart), 'Easy miles', 'Running', 0, 0, 0, 35, 3.5, 'Easy', 'complete', 'Relaxed pace.'],
|
|
[$mayaId, $mayaRoutineId, $exerciseIds['Tempo Run'], app_date($weekStart->modify('+2 days')), 'Tempo intervals', 'Running', 0, 0, 0, 42, 4.2, 'Threshold', 'planned', '3 x 8 min tempo.'],
|
|
[$mayaId, $mayaRoutineId, $exerciseIds['Pool Laps'], app_date($weekStart->modify('+4 days')), 'Recovery swim', 'Swimming', 0, 0, 0, 30, 0, 'Easy', 'planned', 'Smooth form.'],
|
|
];
|
|
foreach ($workouts as $workout) {
|
|
$workoutStmt->execute([...$workout, $created]);
|
|
}
|
|
|
|
$nutritionStmt = $pdo->prepare(
|
|
"INSERT INTO nutrition_logs
|
|
(user_id, logged_on, calories, protein_g, carbs_g, fat_g, water_ml, notes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$nutritionLogs = [
|
|
[$alexId, app_date($today), 1540, 110, 165, 42, 1850, 'Breakfast, shake, and lunch logged.'],
|
|
[$alexId, app_date($today->modify('-1 day')), 2865, 186, 325, 82, 3700, 'Hit the target closely.'],
|
|
[$mayaId, app_date($today), 1210, 74, 164, 31, 1700, 'Morning and lunch logged.'],
|
|
];
|
|
foreach ($nutritionLogs as $log) {
|
|
$nutritionStmt->execute([...$log, $created]);
|
|
}
|
|
|
|
$supplementIds = db_key_values($pdo, "SELECT name, id FROM supplements WHERE is_builtin = 1");
|
|
$supplementLogStmt = $pdo->prepare(
|
|
"INSERT INTO supplement_logs
|
|
(user_id, supplement_id, taken_on, timing, dose, status, notes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$supplementLogs = [
|
|
[$alexId, $supplementIds['Creatine Monohydrate'], app_date($today), 'Daily', '5 g', 'taken', 'With breakfast.'],
|
|
[$alexId, $supplementIds['Pre-Workout Blend'], app_date($today), 'Pre-workout', '1 scoop', 'planned', 'Before pull session.'],
|
|
[$alexId, $supplementIds['Whey Protein'], app_date($today), 'Post-workout', '30 g', 'planned', 'After training.'],
|
|
[$mayaId, $supplementIds['Electrolytes'], app_date($today), 'Intra-workout', '1 serving', 'planned', 'For tempo run.'],
|
|
];
|
|
foreach ($supplementLogs as $log) {
|
|
$supplementLogStmt->execute([...$log, $created]);
|
|
}
|
|
|
|
$metricStmt = $pdo->prepare(
|
|
"INSERT INTO body_metrics
|
|
(user_id, measured_on, weight_lbs, body_fat_pct, sleep_hours, resting_hr, mood, notes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$metrics = [
|
|
[$alexId, app_date($today), 184.2, 14.8, 7.1, 58, 'Focused', 'Lower back feels good.'],
|
|
[$alexId, app_date($today->modify('-7 days')), 185.1, 15.0, 6.8, 60, 'Steady', 'Minor shoulder tightness.'],
|
|
[$mayaId, app_date($today), 132.4, 19.6, 7.8, 53, 'Fresh', 'Good recovery.'],
|
|
];
|
|
foreach ($metrics as $metric) {
|
|
$metricStmt->execute([...$metric, $created]);
|
|
}
|
|
}
|
|
|
|
function app_now(): string
|
|
{
|
|
return (new DateTimeImmutable())->format('Y-m-d H:i:s');
|
|
}
|
|
|
|
function app_date(DateTimeImmutable $date): string
|
|
{
|
|
return $date->format('Y-m-d');
|
|
}
|
|
|
|
function parse_app_date(?string $value = null): DateTimeImmutable
|
|
{
|
|
if (!$value) {
|
|
return new DateTimeImmutable('today');
|
|
}
|
|
|
|
$parsed = DateTimeImmutable::createFromFormat('!Y-m-d', $value);
|
|
return $parsed ?: new DateTimeImmutable('today');
|
|
}
|
|
|
|
function range_for_view(string $view, DateTimeImmutable $anchor): array
|
|
{
|
|
if ($view === 'weekly') {
|
|
$start = $anchor->modify('monday this week');
|
|
return [$start, $start->modify('+6 days')];
|
|
}
|
|
|
|
if ($view === 'monthly') {
|
|
$start = $anchor->modify('first day of this month');
|
|
return [$start, $anchor->modify('last day of this month')];
|
|
}
|
|
|
|
return [$anchor, $anchor];
|
|
}
|
|
|
|
function db_all(PDO $pdo, string $sql, array $params = []): array
|
|
{
|
|
$stmt = $pdo->prepare($sql);
|
|
$stmt->execute($params);
|
|
return $stmt->fetchAll();
|
|
}
|
|
|
|
function db_one(PDO $pdo, string $sql, array $params = []): ?array
|
|
{
|
|
$stmt = $pdo->prepare($sql);
|
|
$stmt->execute($params);
|
|
$row = $stmt->fetch();
|
|
return $row ?: null;
|
|
}
|
|
|
|
function db_value(PDO $pdo, string $sql, array $params = []): mixed
|
|
{
|
|
$stmt = $pdo->prepare($sql);
|
|
$stmt->execute($params);
|
|
return $stmt->fetchColumn();
|
|
}
|
|
|
|
function db_key_values(PDO $pdo, string $sql, array $params = []): array
|
|
{
|
|
$rows = db_all($pdo, $sql, $params);
|
|
$values = [];
|
|
foreach ($rows as $row) {
|
|
$values[$row['name']] = (int) $row['id'];
|
|
}
|
|
return $values;
|
|
}
|
|
|
|
function text_value(array $data, string $key, string $default = ''): string
|
|
{
|
|
if (!array_key_exists($key, $data) || $data[$key] === null) {
|
|
return $default;
|
|
}
|
|
|
|
$value = trim((string) $data[$key]);
|
|
return $value === '' ? $default : $value;
|
|
}
|
|
|
|
function number_value(array $data, string $key, float $default = 0): float
|
|
{
|
|
if (!array_key_exists($key, $data) || $data[$key] === '' || $data[$key] === null) {
|
|
return $default;
|
|
}
|
|
|
|
return is_numeric($data[$key]) ? (float) $data[$key] : $default;
|
|
}
|
|
|
|
function int_value(array $data, string $key, int $default = 0): int
|
|
{
|
|
return (int) number_value($data, $key, $default);
|
|
}
|
|
|
|
function user_id_value(array $data): int
|
|
{
|
|
$userId = int_value($data, 'user_id');
|
|
if ($userId <= 0) {
|
|
throw new InvalidArgumentException('A valid profile is required.');
|
|
}
|
|
|
|
return $userId;
|
|
}
|
|
|
|
function clamp_choice(string $value, array $choices, string $fallback): string
|
|
{
|
|
return in_array($value, $choices, true) ? $value : $fallback;
|
|
}
|
|
|
|
function nutrition_goal_for(PDO $pdo, int $userId, string $view, DateTimeImmutable $start, DateTimeImmutable $end): array
|
|
{
|
|
$goal = db_one(
|
|
$pdo,
|
|
"SELECT * FROM nutrition_goals
|
|
WHERE user_id = ? AND scope = ? AND start_date <= ?
|
|
ORDER BY start_date DESC, id DESC
|
|
LIMIT 1",
|
|
[$userId, $view, app_date($end)]
|
|
);
|
|
|
|
if ($goal) {
|
|
$goal['scaled_from'] = $goal['scope'];
|
|
return $goal;
|
|
}
|
|
|
|
$daily = db_one(
|
|
$pdo,
|
|
"SELECT * FROM nutrition_goals
|
|
WHERE user_id = ? AND scope = 'daily' AND start_date <= ?
|
|
ORDER BY start_date DESC, id DESC
|
|
LIMIT 1",
|
|
[$userId, app_date($end)]
|
|
);
|
|
|
|
if ($daily) {
|
|
$days = ((int) $start->diff($end)->format('%a')) + 1;
|
|
foreach (['calories', 'protein_g', 'carbs_g', 'fat_g', 'water_ml'] as $field) {
|
|
$daily[$field] = (float) $daily[$field] * $days;
|
|
}
|
|
$daily['label'] = $daily['label'] . ' x ' . $days . ' days';
|
|
$daily['scope'] = $view;
|
|
$daily['scaled_from'] = 'daily';
|
|
return $daily;
|
|
}
|
|
|
|
return [
|
|
'id' => null,
|
|
'label' => 'No target',
|
|
'scope' => $view,
|
|
'calories' => 0,
|
|
'protein_g' => 0,
|
|
'carbs_g' => 0,
|
|
'fat_g' => 0,
|
|
'water_ml' => 0,
|
|
'start_date' => app_date($start),
|
|
'scaled_from' => 'none',
|
|
];
|
|
}
|
|
|
|
function nutrition_totals(PDO $pdo, int $userId, DateTimeImmutable $start, DateTimeImmutable $end): array
|
|
{
|
|
$row = db_one(
|
|
$pdo,
|
|
"SELECT
|
|
COALESCE(SUM(calories), 0) AS calories,
|
|
COALESCE(SUM(protein_g), 0) AS protein_g,
|
|
COALESCE(SUM(carbs_g), 0) AS carbs_g,
|
|
COALESCE(SUM(fat_g), 0) AS fat_g,
|
|
COALESCE(SUM(water_ml), 0) AS water_ml
|
|
FROM nutrition_logs
|
|
WHERE user_id = ? AND logged_on BETWEEN ? AND ?",
|
|
[$userId, app_date($start), app_date($end)]
|
|
) ?? [];
|
|
|
|
foreach (['calories', 'protein_g', 'carbs_g', 'fat_g', 'water_ml'] as $field) {
|
|
$row[$field] = (float) ($row[$field] ?? 0);
|
|
}
|
|
|
|
return $row;
|
|
}
|
|
|
|
function workout_summary(array $workouts): array
|
|
{
|
|
$planned = count($workouts);
|
|
$completed = 0;
|
|
$skipped = 0;
|
|
$minutes = 0.0;
|
|
$distance = 0.0;
|
|
$volume = 0.0;
|
|
|
|
foreach ($workouts as $workout) {
|
|
if ($workout['status'] === 'complete') {
|
|
$completed++;
|
|
}
|
|
if ($workout['status'] === 'skipped') {
|
|
$skipped++;
|
|
}
|
|
|
|
$minutes += (float) $workout['duration_min'];
|
|
$distance += (float) $workout['distance_mi'];
|
|
$volume += (float) $workout['sets'] * (float) $workout['reps'] * (float) $workout['weight_lbs'];
|
|
}
|
|
|
|
return [
|
|
'planned' => $planned,
|
|
'completed' => $completed,
|
|
'skipped' => $skipped,
|
|
'minutes' => round($minutes, 1),
|
|
'distance_mi' => round($distance, 2),
|
|
'weight_volume_lbs' => round($volume, 1),
|
|
'completion_rate' => $planned > 0 ? round(($completed / $planned) * 100, 1) : 0,
|
|
];
|
|
}
|
|
|
|
function is_admin(PDO $pdo, int $userId): bool
|
|
{
|
|
if ($userId <= 0) {
|
|
return false;
|
|
}
|
|
|
|
return (bool) db_value(
|
|
$pdo,
|
|
"SELECT COUNT(*) FROM users WHERE id = ? AND role = 'admin' AND status = 'active'",
|
|
[$userId]
|
|
);
|
|
}
|
|
|
|
function admin_user_rows(PDO $pdo): array
|
|
{
|
|
return db_all(
|
|
$pdo,
|
|
"SELECT
|
|
users.*,
|
|
(SELECT COUNT(*) FROM routines WHERE routines.user_id = users.id) AS routine_count,
|
|
(SELECT COUNT(*) FROM workouts WHERE workouts.user_id = users.id) AS workout_count,
|
|
(SELECT COUNT(*) FROM nutrition_logs WHERE nutrition_logs.user_id = users.id) AS nutrition_log_count,
|
|
(SELECT COUNT(*) FROM supplement_logs WHERE supplement_logs.user_id = users.id) AS supplement_log_count,
|
|
(SELECT COUNT(*) FROM body_metrics WHERE body_metrics.user_id = users.id) AS metric_count,
|
|
(SELECT MAX(measured_on) FROM body_metrics WHERE body_metrics.user_id = users.id) AS last_metric_on
|
|
FROM users
|
|
ORDER BY
|
|
CASE users.status WHEN 'active' THEN 0 ELSE 1 END,
|
|
CASE users.role WHEN 'admin' THEN 0 ELSE 1 END,
|
|
users.name"
|
|
);
|
|
}
|
|
|
|
function admin_summary(PDO $pdo): array
|
|
{
|
|
return [
|
|
'total_users' => (int) db_value($pdo, 'SELECT COUNT(*) FROM users'),
|
|
'active_users' => (int) db_value($pdo, "SELECT COUNT(*) FROM users WHERE status = 'active'"),
|
|
'inactive_users' => (int) db_value($pdo, "SELECT COUNT(*) FROM users WHERE status <> 'active'"),
|
|
'admins' => (int) db_value($pdo, "SELECT COUNT(*) FROM users WHERE role = 'admin'"),
|
|
'members' => (int) db_value($pdo, "SELECT COUNT(*) FROM users WHERE role = 'member'"),
|
|
];
|
|
}
|
|
|
|
function require_admin(PDO $pdo, array $data): int
|
|
{
|
|
$actingUserId = int_value($data, 'acting_user_id') ?: int_value($data, 'user_id');
|
|
if (!is_admin($pdo, $actingUserId)) {
|
|
throw new InvalidArgumentException('Admin access is required.');
|
|
}
|
|
|
|
return $actingUserId;
|
|
}
|
|
|
|
function last_admin_guard(PDO $pdo, int $targetUserId, string $nextRole, string $nextStatus): void
|
|
{
|
|
$target = db_one($pdo, 'SELECT id, role, status FROM users WHERE id = ?', [$targetUserId]);
|
|
if (!$target || $target['role'] !== 'admin' || $target['status'] !== 'active') {
|
|
return;
|
|
}
|
|
|
|
$wouldRemainActiveAdmin = $nextRole === 'admin' && $nextStatus === 'active';
|
|
if ($wouldRemainActiveAdmin) {
|
|
return;
|
|
}
|
|
|
|
$activeAdmins = (int) db_value($pdo, "SELECT COUNT(*) FROM users WHERE role = 'admin' AND status = 'active'");
|
|
if ($activeAdmins <= 1) {
|
|
throw new InvalidArgumentException('At least one active admin profile is required.');
|
|
}
|
|
}
|
|
|
|
function state_payload(array $query): array
|
|
{
|
|
$pdo = app_db();
|
|
$view = clamp_choice((string) ($query['view'] ?? 'daily'), ['daily', 'weekly', 'monthly'], 'daily');
|
|
$anchor = parse_app_date(isset($query['date']) ? (string) $query['date'] : null);
|
|
[$start, $end] = range_for_view($view, $anchor);
|
|
|
|
$users = db_all($pdo, "SELECT * FROM users WHERE status = 'active' ORDER BY id");
|
|
if (!$users) {
|
|
seed_demo_data($pdo);
|
|
ensure_first_user_is_admin($pdo);
|
|
$users = db_all($pdo, "SELECT * FROM users WHERE status = 'active' ORDER BY id");
|
|
}
|
|
if (!$users) {
|
|
$users = db_all($pdo, 'SELECT * FROM users ORDER BY id');
|
|
}
|
|
|
|
$requestedUserId = isset($query['user_id']) ? (int) $query['user_id'] : (int) $users[0]['id'];
|
|
$currentUser = $users[0];
|
|
foreach ($users as $user) {
|
|
if ((int) $user['id'] === $requestedUserId) {
|
|
$currentUser = $user;
|
|
break;
|
|
}
|
|
}
|
|
$userId = (int) $currentUser['id'];
|
|
$currentUserIsAdmin = is_admin($pdo, $userId);
|
|
|
|
$exercises = db_all(
|
|
$pdo,
|
|
"SELECT * FROM exercises
|
|
WHERE is_builtin = 1 OR user_id = ?
|
|
ORDER BY is_builtin DESC, category, name",
|
|
[$userId]
|
|
);
|
|
$supplements = db_all(
|
|
$pdo,
|
|
"SELECT * FROM supplements
|
|
WHERE is_builtin = 1 OR user_id = ?
|
|
ORDER BY timing, name",
|
|
[$userId]
|
|
);
|
|
$nutritionGoals = db_all(
|
|
$pdo,
|
|
"SELECT * FROM nutrition_goals
|
|
WHERE user_id = ?
|
|
ORDER BY start_date DESC, scope, label",
|
|
[$userId]
|
|
);
|
|
$routines = db_all(
|
|
$pdo,
|
|
"SELECT routines.*, nutrition_goals.label AS nutrition_goal_label
|
|
FROM routines
|
|
LEFT JOIN nutrition_goals ON nutrition_goals.id = routines.nutrition_goal_id
|
|
WHERE routines.user_id = ?
|
|
ORDER BY routines.active DESC, routines.start_date DESC, routines.name",
|
|
[$userId]
|
|
);
|
|
$workouts = db_all(
|
|
$pdo,
|
|
"SELECT workouts.*, exercises.name AS exercise_name, routines.name AS routine_name
|
|
FROM workouts
|
|
LEFT JOIN exercises ON exercises.id = workouts.exercise_id
|
|
LEFT JOIN routines ON routines.id = workouts.routine_id
|
|
WHERE workouts.user_id = ? AND workouts.scheduled_on BETWEEN ? AND ?
|
|
ORDER BY workouts.scheduled_on, workouts.id",
|
|
[$userId, app_date($start), app_date($end)]
|
|
);
|
|
$nutritionLogs = db_all(
|
|
$pdo,
|
|
"SELECT * FROM nutrition_logs
|
|
WHERE user_id = ? AND logged_on BETWEEN ? AND ?
|
|
ORDER BY logged_on DESC, id DESC",
|
|
[$userId, app_date($start), app_date($end)]
|
|
);
|
|
$supplementLogs = db_all(
|
|
$pdo,
|
|
"SELECT supplement_logs.*, supplements.name AS supplement_name, supplements.purpose AS supplement_purpose
|
|
FROM supplement_logs
|
|
LEFT JOIN supplements ON supplements.id = supplement_logs.supplement_id
|
|
WHERE supplement_logs.user_id = ? AND supplement_logs.taken_on BETWEEN ? AND ?
|
|
ORDER BY supplement_logs.taken_on DESC, supplement_logs.id DESC",
|
|
[$userId, app_date($start), app_date($end)]
|
|
);
|
|
$bodyMetrics = db_all(
|
|
$pdo,
|
|
"SELECT * FROM body_metrics
|
|
WHERE user_id = ? AND measured_on BETWEEN ? AND ?
|
|
ORDER BY measured_on DESC, id DESC",
|
|
[$userId, app_date($start), app_date($end)]
|
|
);
|
|
$latestMetric = db_one(
|
|
$pdo,
|
|
"SELECT * FROM body_metrics
|
|
WHERE user_id = ?
|
|
ORDER BY measured_on DESC, id DESC
|
|
LIMIT 1",
|
|
[$userId]
|
|
);
|
|
|
|
return [
|
|
'users' => $users,
|
|
'adminUsers' => $currentUserIsAdmin ? admin_user_rows($pdo) : [],
|
|
'adminSummary' => $currentUserIsAdmin ? admin_summary($pdo) : null,
|
|
'currentUser' => $currentUser,
|
|
'currentUserIsAdmin' => $currentUserIsAdmin,
|
|
'view' => $view,
|
|
'range' => [
|
|
'anchor' => app_date($anchor),
|
|
'start' => app_date($start),
|
|
'end' => app_date($end),
|
|
'days' => ((int) $start->diff($end)->format('%a')) + 1,
|
|
],
|
|
'exercises' => $exercises,
|
|
'supplements' => $supplements,
|
|
'nutritionGoals' => $nutritionGoals,
|
|
'routines' => $routines,
|
|
'workouts' => $workouts,
|
|
'nutritionLogs' => $nutritionLogs,
|
|
'supplementLogs' => $supplementLogs,
|
|
'bodyMetrics' => $bodyMetrics,
|
|
'latestMetric' => $latestMetric,
|
|
'nutritionSummary' => [
|
|
'target' => nutrition_goal_for($pdo, $userId, $view, $start, $end),
|
|
'actual' => nutrition_totals($pdo, $userId, $start, $end),
|
|
],
|
|
'workoutSummary' => workout_summary($workouts),
|
|
];
|
|
}
|
|
|
|
function create_user(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$name = text_value($data, 'name');
|
|
if ($name === '') {
|
|
throw new InvalidArgumentException('Profile name is required.');
|
|
}
|
|
|
|
$userCount = (int) db_value($pdo, 'SELECT COUNT(*) FROM users');
|
|
if ($userCount > 0) {
|
|
require_admin($pdo, $data);
|
|
}
|
|
|
|
$role = $userCount === 0
|
|
? 'admin'
|
|
: clamp_choice(text_value($data, 'role', 'member'), ['admin', 'member'], 'member');
|
|
$status = clamp_choice(text_value($data, 'status', 'active'), ['active', 'inactive'], 'active');
|
|
$mode = clamp_choice(text_value($data, 'theme_mode', 'dark'), ['dark', 'light'], 'dark');
|
|
$accent = clamp_choice(text_value($data, 'theme_accent', 'green'), ['green', 'blue', 'red', 'pink', 'orange'], 'green');
|
|
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO users
|
|
(name, email, fitness_focus, role, status, phone, birthday, height_in, training_level,
|
|
emergency_contact, theme_mode, theme_accent, updated_at, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$name,
|
|
text_value($data, 'email'),
|
|
text_value($data, 'fitness_focus'),
|
|
$role,
|
|
$status,
|
|
text_value($data, 'phone'),
|
|
text_value($data, 'birthday'),
|
|
number_value($data, 'height_in'),
|
|
text_value($data, 'training_level'),
|
|
text_value($data, 'emergency_contact'),
|
|
$mode,
|
|
$accent,
|
|
app_now(),
|
|
app_now(),
|
|
]);
|
|
$userId = (int) $pdo->lastInsertId();
|
|
|
|
$goalStmt = $pdo->prepare(
|
|
"INSERT INTO nutrition_goals
|
|
(user_id, label, scope, calories, protein_g, carbs_g, fat_g, water_ml, start_date, created_at)
|
|
VALUES (?, 'Starter day', 'daily', 2400, 150, 260, 75, 3000, ?, ?)"
|
|
);
|
|
$goalStmt->execute([$userId, app_date(new DateTimeImmutable('today')), app_now()]);
|
|
|
|
return ['user' => db_one($pdo, 'SELECT * FROM users WHERE id = ?', [$userId])];
|
|
}
|
|
|
|
function public_signup(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$name = text_value($data, 'name');
|
|
if ($name === '') {
|
|
throw new InvalidArgumentException('Name is required.');
|
|
}
|
|
|
|
$userCount = (int) db_value($pdo, 'SELECT COUNT(*) FROM users');
|
|
$role = $userCount === 0 ? 'admin' : 'member';
|
|
$created = app_now();
|
|
$mode = clamp_choice(text_value($data, 'theme_mode', 'dark'), ['dark', 'light'], 'dark');
|
|
$accent = clamp_choice(text_value($data, 'theme_accent', 'green'), ['green', 'blue', 'red', 'pink', 'orange'], 'green');
|
|
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO users
|
|
(name, email, fitness_focus, role, status, phone, birthday, height_in, training_level,
|
|
emergency_contact, theme_mode, theme_accent, updated_at, created_at)
|
|
VALUES (?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$name,
|
|
text_value($data, 'email'),
|
|
text_value($data, 'fitness_focus'),
|
|
$role,
|
|
text_value($data, 'phone'),
|
|
text_value($data, 'birthday'),
|
|
number_value($data, 'height_in'),
|
|
text_value($data, 'training_level'),
|
|
text_value($data, 'emergency_contact'),
|
|
$mode,
|
|
$accent,
|
|
$created,
|
|
$created,
|
|
]);
|
|
$userId = (int) $pdo->lastInsertId();
|
|
|
|
$goalStmt = $pdo->prepare(
|
|
"INSERT INTO nutrition_goals
|
|
(user_id, label, scope, calories, protein_g, carbs_g, fat_g, water_ml, start_date, created_at)
|
|
VALUES (?, 'Starter day', 'daily', 2400, 150, 260, 75, 3000, ?, ?)"
|
|
);
|
|
$goalStmt->execute([$userId, app_date(new DateTimeImmutable('today')), $created]);
|
|
|
|
return [
|
|
'user' => db_one($pdo, 'SELECT * FROM users WHERE id = ?', [$userId]),
|
|
'first_admin' => $role === 'admin',
|
|
];
|
|
}
|
|
|
|
function update_user(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
require_admin($pdo, $data);
|
|
|
|
$targetUserId = int_value($data, 'target_user_id');
|
|
if ($targetUserId <= 0) {
|
|
throw new InvalidArgumentException('Target profile is required.');
|
|
}
|
|
|
|
$current = db_one($pdo, 'SELECT * FROM users WHERE id = ?', [$targetUserId]);
|
|
if (!$current) {
|
|
throw new InvalidArgumentException('Profile not found.');
|
|
}
|
|
|
|
$nextRole = array_key_exists('role', $data)
|
|
? clamp_choice(text_value($data, 'role', $current['role']), ['admin', 'member'], $current['role'])
|
|
: $current['role'];
|
|
$nextStatus = array_key_exists('status', $data)
|
|
? clamp_choice(text_value($data, 'status', $current['status']), ['active', 'inactive'], $current['status'])
|
|
: $current['status'];
|
|
last_admin_guard($pdo, $targetUserId, $nextRole, $nextStatus);
|
|
|
|
$fields = [
|
|
'name' => array_key_exists('name', $data) ? text_value($data, 'name', $current['name']) : $current['name'],
|
|
'email' => array_key_exists('email', $data) ? text_value($data, 'email') : $current['email'],
|
|
'fitness_focus' => array_key_exists('fitness_focus', $data) ? text_value($data, 'fitness_focus') : $current['fitness_focus'],
|
|
'role' => $nextRole,
|
|
'status' => $nextStatus,
|
|
'phone' => array_key_exists('phone', $data) ? text_value($data, 'phone') : $current['phone'],
|
|
'birthday' => array_key_exists('birthday', $data) ? text_value($data, 'birthday') : $current['birthday'],
|
|
'height_in' => array_key_exists('height_in', $data) ? number_value($data, 'height_in') : (float) $current['height_in'],
|
|
'training_level' => array_key_exists('training_level', $data) ? text_value($data, 'training_level') : $current['training_level'],
|
|
'emergency_contact' => array_key_exists('emergency_contact', $data) ? text_value($data, 'emergency_contact') : $current['emergency_contact'],
|
|
'theme_mode' => array_key_exists('theme_mode', $data)
|
|
? clamp_choice(text_value($data, 'theme_mode', $current['theme_mode']), ['dark', 'light'], $current['theme_mode'])
|
|
: $current['theme_mode'],
|
|
'theme_accent' => array_key_exists('theme_accent', $data)
|
|
? clamp_choice(text_value($data, 'theme_accent', $current['theme_accent']), ['green', 'blue', 'red', 'pink', 'orange'], $current['theme_accent'])
|
|
: $current['theme_accent'],
|
|
];
|
|
|
|
if ($fields['name'] === '') {
|
|
throw new InvalidArgumentException('Profile name is required.');
|
|
}
|
|
|
|
$stmt = $pdo->prepare(
|
|
"UPDATE users
|
|
SET name = ?, email = ?, fitness_focus = ?, role = ?, status = ?, phone = ?, birthday = ?,
|
|
height_in = ?, training_level = ?, emergency_contact = ?, theme_mode = ?, theme_accent = ?, updated_at = ?
|
|
WHERE id = ?"
|
|
);
|
|
$stmt->execute([
|
|
$fields['name'],
|
|
$fields['email'],
|
|
$fields['fitness_focus'],
|
|
$fields['role'],
|
|
$fields['status'],
|
|
$fields['phone'],
|
|
$fields['birthday'],
|
|
$fields['height_in'],
|
|
$fields['training_level'],
|
|
$fields['emergency_contact'],
|
|
$fields['theme_mode'],
|
|
$fields['theme_accent'],
|
|
app_now(),
|
|
$targetUserId,
|
|
]);
|
|
|
|
return ['user' => db_one($pdo, 'SELECT * FROM users WHERE id = ?', [$targetUserId])];
|
|
}
|
|
|
|
function delete_user(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$actingUserId = require_admin($pdo, $data);
|
|
$targetUserId = int_value($data, 'target_user_id');
|
|
if ($targetUserId <= 0) {
|
|
throw new InvalidArgumentException('Target profile is required.');
|
|
}
|
|
if ($targetUserId === $actingUserId) {
|
|
throw new InvalidArgumentException('You cannot delete the profile you are currently using.');
|
|
}
|
|
|
|
$target = db_one($pdo, 'SELECT * FROM users WHERE id = ?', [$targetUserId]);
|
|
if (!$target) {
|
|
throw new InvalidArgumentException('Profile not found.');
|
|
}
|
|
last_admin_guard($pdo, $targetUserId, 'member', 'inactive');
|
|
|
|
$stmt = $pdo->prepare('DELETE FROM users WHERE id = ?');
|
|
$stmt->execute([$targetUserId]);
|
|
|
|
return ['deleted' => true, 'target_user_id' => $targetUserId];
|
|
}
|
|
|
|
function update_theme(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$mode = clamp_choice(text_value($data, 'theme_mode', 'dark'), ['dark', 'light'], 'dark');
|
|
$accent = clamp_choice(text_value($data, 'theme_accent', 'green'), ['green', 'blue', 'red', 'pink', 'orange'], 'green');
|
|
$stmt = $pdo->prepare('UPDATE users SET theme_mode = ?, theme_accent = ? WHERE id = ?');
|
|
$stmt->execute([$mode, $accent, $userId]);
|
|
|
|
return ['user' => db_one($pdo, 'SELECT * FROM users WHERE id = ?', [$userId])];
|
|
}
|
|
|
|
function create_exercise(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$name = text_value($data, 'name');
|
|
if ($name === '') {
|
|
throw new InvalidArgumentException('Exercise name is required.');
|
|
}
|
|
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO exercises (user_id, name, category, muscle_group, default_unit, notes, is_builtin, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, 0, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$userId,
|
|
$name,
|
|
text_value($data, 'category', 'Custom'),
|
|
text_value($data, 'muscle_group'),
|
|
text_value($data, 'default_unit'),
|
|
text_value($data, 'notes'),
|
|
app_now(),
|
|
]);
|
|
|
|
return ['exercise' => db_one($pdo, 'SELECT * FROM exercises WHERE id = ?', [(int) $pdo->lastInsertId()])];
|
|
}
|
|
|
|
function create_supplement(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$name = text_value($data, 'name');
|
|
if ($name === '') {
|
|
throw new InvalidArgumentException('Supplement name is required.');
|
|
}
|
|
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO supplements (user_id, name, timing, default_dose, purpose, notes, is_builtin, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, 0, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$userId,
|
|
$name,
|
|
text_value($data, 'timing', 'Daily'),
|
|
text_value($data, 'default_dose'),
|
|
text_value($data, 'purpose'),
|
|
text_value($data, 'notes'),
|
|
app_now(),
|
|
]);
|
|
|
|
return ['supplement' => db_one($pdo, 'SELECT * FROM supplements WHERE id = ?', [(int) $pdo->lastInsertId()])];
|
|
}
|
|
|
|
function create_nutrition_goal(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$scope = clamp_choice(text_value($data, 'scope', 'daily'), ['daily', 'weekly', 'monthly'], 'daily');
|
|
$label = text_value($data, 'label', ucfirst($scope) . ' target');
|
|
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO nutrition_goals
|
|
(user_id, label, scope, calories, protein_g, carbs_g, fat_g, water_ml, start_date, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$userId,
|
|
$label,
|
|
$scope,
|
|
number_value($data, 'calories'),
|
|
number_value($data, 'protein_g'),
|
|
number_value($data, 'carbs_g'),
|
|
number_value($data, 'fat_g'),
|
|
number_value($data, 'water_ml'),
|
|
app_date(parse_app_date(text_value($data, 'start_date'))),
|
|
app_now(),
|
|
]);
|
|
|
|
return ['nutritionGoal' => db_one($pdo, 'SELECT * FROM nutrition_goals WHERE id = ?', [(int) $pdo->lastInsertId()])];
|
|
}
|
|
|
|
function create_routine(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$name = text_value($data, 'name');
|
|
if ($name === '') {
|
|
throw new InvalidArgumentException('Routine name is required.');
|
|
}
|
|
|
|
$scope = clamp_choice(text_value($data, 'planner_scope', 'weekly'), ['daily', 'weekly', 'monthly'], 'weekly');
|
|
$goalId = int_value($data, 'nutrition_goal_id') ?: null;
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO routines
|
|
(user_id, nutrition_goal_id, name, workout_type, planner_scope, start_date, end_date, intensity, notes, active, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$userId,
|
|
$goalId,
|
|
$name,
|
|
text_value($data, 'workout_type', 'Hybrid'),
|
|
$scope,
|
|
app_date(parse_app_date(text_value($data, 'start_date'))),
|
|
text_value($data, 'end_date'),
|
|
text_value($data, 'intensity'),
|
|
text_value($data, 'notes'),
|
|
app_now(),
|
|
]);
|
|
|
|
return ['routine' => db_one($pdo, 'SELECT * FROM routines WHERE id = ?', [(int) $pdo->lastInsertId()])];
|
|
}
|
|
|
|
function create_workout(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$title = text_value($data, 'title');
|
|
if ($title === '') {
|
|
throw new InvalidArgumentException('Workout title is required.');
|
|
}
|
|
|
|
$status = clamp_choice(text_value($data, 'status', 'planned'), ['planned', 'complete', 'skipped'], 'planned');
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO workouts
|
|
(user_id, routine_id, exercise_id, scheduled_on, title, workout_type, sets, reps, weight_lbs,
|
|
duration_min, distance_mi, intensity, status, notes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$userId,
|
|
int_value($data, 'routine_id') ?: null,
|
|
int_value($data, 'exercise_id') ?: null,
|
|
app_date(parse_app_date(text_value($data, 'scheduled_on'))),
|
|
$title,
|
|
text_value($data, 'workout_type', 'Weight lifting'),
|
|
int_value($data, 'sets'),
|
|
int_value($data, 'reps'),
|
|
number_value($data, 'weight_lbs'),
|
|
number_value($data, 'duration_min'),
|
|
number_value($data, 'distance_mi'),
|
|
text_value($data, 'intensity'),
|
|
$status,
|
|
text_value($data, 'notes'),
|
|
app_now(),
|
|
]);
|
|
|
|
return ['workout' => db_one($pdo, 'SELECT * FROM workouts WHERE id = ?', [(int) $pdo->lastInsertId()])];
|
|
}
|
|
|
|
function update_workout(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$workoutId = int_value($data, 'id');
|
|
if ($workoutId <= 0) {
|
|
throw new InvalidArgumentException('Workout id is required.');
|
|
}
|
|
|
|
$allowed = [
|
|
'title' => 'text',
|
|
'workout_type' => 'text',
|
|
'intensity' => 'text',
|
|
'notes' => 'text',
|
|
'scheduled_on' => 'date',
|
|
'status' => 'status',
|
|
'sets' => 'int',
|
|
'reps' => 'int',
|
|
'weight_lbs' => 'float',
|
|
'duration_min' => 'float',
|
|
'distance_mi' => 'float',
|
|
];
|
|
$fields = [];
|
|
$values = [];
|
|
|
|
foreach ($allowed as $field => $type) {
|
|
if (!array_key_exists($field, $data)) {
|
|
continue;
|
|
}
|
|
$fields[] = $field . ' = ?';
|
|
if ($type === 'date') {
|
|
$values[] = app_date(parse_app_date(text_value($data, $field)));
|
|
} elseif ($type === 'status') {
|
|
$values[] = clamp_choice(text_value($data, $field, 'planned'), ['planned', 'complete', 'skipped'], 'planned');
|
|
} elseif ($type === 'int') {
|
|
$values[] = int_value($data, $field);
|
|
} elseif ($type === 'float') {
|
|
$values[] = number_value($data, $field);
|
|
} else {
|
|
$values[] = text_value($data, $field);
|
|
}
|
|
}
|
|
|
|
if (!$fields) {
|
|
throw new InvalidArgumentException('No workout updates supplied.');
|
|
}
|
|
|
|
$values[] = $workoutId;
|
|
$stmt = $pdo->prepare('UPDATE workouts SET ' . implode(', ', $fields) . ' WHERE id = ?');
|
|
$stmt->execute($values);
|
|
|
|
return ['workout' => db_one($pdo, 'SELECT * FROM workouts WHERE id = ?', [$workoutId])];
|
|
}
|
|
|
|
function create_nutrition_log(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO nutrition_logs
|
|
(user_id, logged_on, calories, protein_g, carbs_g, fat_g, water_ml, notes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$userId,
|
|
app_date(parse_app_date(text_value($data, 'logged_on'))),
|
|
number_value($data, 'calories'),
|
|
number_value($data, 'protein_g'),
|
|
number_value($data, 'carbs_g'),
|
|
number_value($data, 'fat_g'),
|
|
number_value($data, 'water_ml'),
|
|
text_value($data, 'notes'),
|
|
app_now(),
|
|
]);
|
|
|
|
return ['nutritionLog' => db_one($pdo, 'SELECT * FROM nutrition_logs WHERE id = ?', [(int) $pdo->lastInsertId()])];
|
|
}
|
|
|
|
function create_supplement_log(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$status = clamp_choice(text_value($data, 'status', 'planned'), ['planned', 'taken', 'skipped'], 'planned');
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO supplement_logs
|
|
(user_id, supplement_id, taken_on, timing, dose, status, notes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$userId,
|
|
int_value($data, 'supplement_id') ?: null,
|
|
app_date(parse_app_date(text_value($data, 'taken_on'))),
|
|
text_value($data, 'timing', 'Daily'),
|
|
text_value($data, 'dose'),
|
|
$status,
|
|
text_value($data, 'notes'),
|
|
app_now(),
|
|
]);
|
|
|
|
return ['supplementLog' => db_one($pdo, 'SELECT * FROM supplement_logs WHERE id = ?', [(int) $pdo->lastInsertId()])];
|
|
}
|
|
|
|
function create_body_metric(array $data): array
|
|
{
|
|
$pdo = app_db();
|
|
$userId = user_id_value($data);
|
|
$stmt = $pdo->prepare(
|
|
"INSERT INTO body_metrics
|
|
(user_id, measured_on, weight_lbs, body_fat_pct, sleep_hours, resting_hr, mood, notes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$stmt->execute([
|
|
$userId,
|
|
app_date(parse_app_date(text_value($data, 'measured_on'))),
|
|
number_value($data, 'weight_lbs'),
|
|
number_value($data, 'body_fat_pct'),
|
|
number_value($data, 'sleep_hours'),
|
|
int_value($data, 'resting_hr'),
|
|
text_value($data, 'mood'),
|
|
text_value($data, 'notes'),
|
|
app_now(),
|
|
]);
|
|
|
|
return ['bodyMetric' => db_one($pdo, 'SELECT * FROM body_metrics WHERE id = ?', [(int) $pdo->lastInsertId()])];
|
|
}
|
|
|
|
function json_input(): array
|
|
{
|
|
$raw = file_get_contents('php://input');
|
|
if (!$raw) {
|
|
return [];
|
|
}
|
|
|
|
$data = json_decode($raw, true);
|
|
if (!is_array($data)) {
|
|
throw new InvalidArgumentException('Invalid JSON payload.');
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
function json_response(array $payload, int $status = 200): void
|
|
{
|
|
http_response_code($status);
|
|
header('Content-Type: application/json; charset=utf-8');
|
|
header('Cache-Control: no-store');
|
|
echo json_encode($payload, JSON_THROW_ON_ERROR);
|
|
}
|