Lars
2303c04123
NEW FEATURE: Filter conditions for goal types
Enables counting/aggregating specific subsets of data.
Example use case: Count only strength training sessions per week
- Create goal type with filter: {"training_type": "strength"}
- count_7d now counts only strength training, not all activities
Implementation:
- Migration 026: filter_conditions JSONB column
- Backend: Dynamic WHERE clause building from JSON filters
- Supports single value: {"training_type": "strength"}
- Supports multiple values: {"training_type": ["strength", "hiit"]}
- Works with all 8 aggregation methods (count, avg, sum, min, max)
- Frontend: JSON textarea with example + validation
- Pydantic models: filter_conditions field added
Technical details:
- SQL injection safe (parameterized queries)
- Graceful degradation (invalid JSON ignored with warning)
- Backward compatible (NULL filters = no filtering)
Answers user question: 'Kann ich Trainingstypen wie Krafttraining separat zählen?'
Answer: YES! 🎯
882 lines
31 KiB
Python
882 lines
31 KiB
Python
"""
|
|
Goals Router - Goal System (Strategic + Tactical)
|
|
|
|
Endpoints for managing:
|
|
- Strategic goal modes (weight_loss, strength, etc.)
|
|
- Tactical goal targets (concrete values with deadlines)
|
|
- Training phase detection
|
|
- Fitness tests
|
|
|
|
Part of v9e Goal System implementation.
|
|
"""
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from pydantic import BaseModel
|
|
from typing import Optional, List
|
|
from datetime import date, datetime, timedelta
|
|
from decimal import Decimal
|
|
import traceback
|
|
|
|
from db import get_db, get_cursor, r2d
|
|
from auth import require_auth
|
|
from goal_utils import get_current_value_for_goal
|
|
|
|
router = APIRouter(prefix="/api/goals", tags=["goals"])
|
|
|
|
# ============================================================================
|
|
# Pydantic Models
|
|
# ============================================================================
|
|
|
|
class GoalModeUpdate(BaseModel):
|
|
"""Update strategic goal mode"""
|
|
goal_mode: str # weight_loss, strength, endurance, recomposition, health
|
|
|
|
class GoalCreate(BaseModel):
|
|
"""Create or update a concrete goal"""
|
|
goal_type: str # weight, body_fat, lean_mass, vo2max, strength, flexibility, bp, rhr
|
|
is_primary: bool = False
|
|
target_value: float
|
|
unit: str # kg, %, ml/kg/min, bpm, mmHg, cm, reps
|
|
target_date: Optional[date] = None
|
|
name: Optional[str] = None
|
|
description: Optional[str] = None
|
|
|
|
class GoalUpdate(BaseModel):
|
|
"""Update existing goal"""
|
|
target_value: Optional[float] = None
|
|
target_date: Optional[date] = None
|
|
status: Optional[str] = None # active, reached, abandoned, expired
|
|
is_primary: Optional[bool] = None
|
|
name: Optional[str] = None
|
|
description: Optional[str] = None
|
|
|
|
class TrainingPhaseCreate(BaseModel):
|
|
"""Create training phase (manual or auto-detected)"""
|
|
phase_type: str # calorie_deficit, calorie_surplus, deload, maintenance, periodization
|
|
start_date: date
|
|
end_date: Optional[date] = None
|
|
notes: Optional[str] = None
|
|
|
|
class FitnessTestCreate(BaseModel):
|
|
"""Record fitness test result"""
|
|
test_type: str
|
|
result_value: float
|
|
result_unit: str
|
|
test_date: date
|
|
test_conditions: Optional[str] = None
|
|
|
|
class GoalTypeCreate(BaseModel):
|
|
"""Create custom goal type definition"""
|
|
type_key: str
|
|
label_de: str
|
|
label_en: Optional[str] = None
|
|
unit: str
|
|
icon: Optional[str] = None
|
|
category: Optional[str] = 'custom'
|
|
source_table: Optional[str] = None
|
|
source_column: Optional[str] = None
|
|
aggregation_method: Optional[str] = 'latest'
|
|
calculation_formula: Optional[str] = None
|
|
filter_conditions: Optional[dict] = None
|
|
description: Optional[str] = None
|
|
|
|
class GoalTypeUpdate(BaseModel):
|
|
"""Update goal type definition"""
|
|
label_de: Optional[str] = None
|
|
label_en: Optional[str] = None
|
|
unit: Optional[str] = None
|
|
icon: Optional[str] = None
|
|
category: Optional[str] = None
|
|
source_table: Optional[str] = None
|
|
source_column: Optional[str] = None
|
|
aggregation_method: Optional[str] = None
|
|
calculation_formula: Optional[str] = None
|
|
filter_conditions: Optional[dict] = None
|
|
description: Optional[str] = None
|
|
is_active: Optional[bool] = None
|
|
|
|
# ============================================================================
|
|
# Strategic Layer: Goal Modes
|
|
# ============================================================================
|
|
|
|
@router.get("/mode")
|
|
def get_goal_mode(session: dict = Depends(require_auth)):
|
|
"""Get user's current strategic goal mode"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute(
|
|
"SELECT goal_mode FROM profiles WHERE id = %s",
|
|
(pid,)
|
|
)
|
|
row = cur.fetchone()
|
|
if not row:
|
|
raise HTTPException(status_code=404, detail="Profil nicht gefunden")
|
|
|
|
return {
|
|
"goal_mode": row['goal_mode'] or 'health',
|
|
"description": _get_goal_mode_description(row['goal_mode'] or 'health')
|
|
}
|
|
|
|
@router.put("/mode")
|
|
def update_goal_mode(data: GoalModeUpdate, session: dict = Depends(require_auth)):
|
|
"""Update user's strategic goal mode"""
|
|
pid = session['profile_id']
|
|
|
|
# Validate goal mode
|
|
valid_modes = ['weight_loss', 'strength', 'endurance', 'recomposition', 'health']
|
|
if data.goal_mode not in valid_modes:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Ungültiger Goal Mode. Erlaubt: {', '.join(valid_modes)}"
|
|
)
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute(
|
|
"UPDATE profiles SET goal_mode = %s WHERE id = %s",
|
|
(data.goal_mode, pid)
|
|
)
|
|
|
|
return {
|
|
"goal_mode": data.goal_mode,
|
|
"description": _get_goal_mode_description(data.goal_mode)
|
|
}
|
|
|
|
def _get_goal_mode_description(mode: str) -> str:
|
|
"""Get description for goal mode"""
|
|
descriptions = {
|
|
'weight_loss': 'Gewichtsreduktion (Kaloriendefizit, Fettabbau)',
|
|
'strength': 'Kraftaufbau (Muskelwachstum, progressive Belastung)',
|
|
'endurance': 'Ausdauer (VO2Max, aerobe Kapazität)',
|
|
'recomposition': 'Körperkomposition (gleichzeitig Fett ab- und Muskeln aufbauen)',
|
|
'health': 'Allgemeine Gesundheit (ausgewogen, präventiv)'
|
|
}
|
|
return descriptions.get(mode, 'Unbekannt')
|
|
|
|
# ============================================================================
|
|
# Tactical Layer: Concrete Goals
|
|
# ============================================================================
|
|
|
|
@router.get("/list")
|
|
def list_goals(session: dict = Depends(require_auth)):
|
|
"""List all goals for current user"""
|
|
pid = session['profile_id']
|
|
|
|
try:
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute("""
|
|
SELECT id, goal_type, is_primary, status,
|
|
target_value, current_value, start_value, unit,
|
|
start_date, target_date, reached_date,
|
|
name, description,
|
|
progress_pct, projection_date, on_track,
|
|
created_at, updated_at
|
|
FROM goals
|
|
WHERE profile_id = %s
|
|
ORDER BY is_primary DESC, created_at DESC
|
|
""", (pid,))
|
|
|
|
goals = [r2d(row) for row in cur.fetchall()]
|
|
print(f"[DEBUG] Loaded {len(goals)} goals for profile {pid}")
|
|
|
|
# Update current values for each goal
|
|
for goal in goals:
|
|
try:
|
|
_update_goal_progress(conn, pid, goal)
|
|
except Exception as e:
|
|
print(f"[ERROR] Failed to update progress for goal {goal.get('id')}: {e}")
|
|
# Continue with other goals even if one fails
|
|
|
|
return goals
|
|
|
|
except Exception as e:
|
|
print(f"[ERROR] list_goals failed: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Fehler beim Laden der Ziele: {str(e)}"
|
|
)
|
|
|
|
@router.post("/create")
|
|
def create_goal(data: GoalCreate, session: dict = Depends(require_auth)):
|
|
"""Create new goal"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
|
|
# If this is set as primary, unset other primary goals
|
|
if data.is_primary:
|
|
cur.execute(
|
|
"UPDATE goals SET is_primary = false WHERE profile_id = %s",
|
|
(pid,)
|
|
)
|
|
|
|
# Get current value for this goal type
|
|
current_value = _get_current_value_for_goal_type(conn, pid, data.goal_type)
|
|
|
|
# Insert goal
|
|
cur.execute("""
|
|
INSERT INTO goals (
|
|
profile_id, goal_type, is_primary,
|
|
target_value, current_value, start_value, unit,
|
|
target_date, name, description
|
|
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
|
RETURNING id
|
|
""", (
|
|
pid, data.goal_type, data.is_primary,
|
|
data.target_value, current_value, current_value, data.unit,
|
|
data.target_date, data.name, data.description
|
|
))
|
|
|
|
goal_id = cur.fetchone()['id']
|
|
|
|
return {"id": goal_id, "message": "Ziel erstellt"}
|
|
|
|
@router.put("/{goal_id}")
|
|
def update_goal(goal_id: str, data: GoalUpdate, session: dict = Depends(require_auth)):
|
|
"""Update existing goal"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
|
|
# Verify ownership
|
|
cur.execute(
|
|
"SELECT id FROM goals WHERE id = %s AND profile_id = %s",
|
|
(goal_id, pid)
|
|
)
|
|
if not cur.fetchone():
|
|
raise HTTPException(status_code=404, detail="Ziel nicht gefunden")
|
|
|
|
# If setting this goal as primary, unset all other primary goals
|
|
if data.is_primary is True:
|
|
cur.execute(
|
|
"UPDATE goals SET is_primary = false WHERE profile_id = %s AND id != %s",
|
|
(pid, goal_id)
|
|
)
|
|
|
|
# Build update query dynamically
|
|
updates = []
|
|
params = []
|
|
|
|
if data.target_value is not None:
|
|
updates.append("target_value = %s")
|
|
params.append(data.target_value)
|
|
|
|
if data.target_date is not None:
|
|
updates.append("target_date = %s")
|
|
params.append(data.target_date)
|
|
|
|
if data.status is not None:
|
|
updates.append("status = %s")
|
|
params.append(data.status)
|
|
if data.status == 'reached':
|
|
updates.append("reached_date = CURRENT_DATE")
|
|
|
|
if data.is_primary is not None:
|
|
updates.append("is_primary = %s")
|
|
params.append(data.is_primary)
|
|
|
|
if data.name is not None:
|
|
updates.append("name = %s")
|
|
params.append(data.name)
|
|
|
|
if data.description is not None:
|
|
updates.append("description = %s")
|
|
params.append(data.description)
|
|
|
|
if not updates:
|
|
raise HTTPException(status_code=400, detail="Keine Änderungen angegeben")
|
|
|
|
updates.append("updated_at = NOW()")
|
|
params.extend([goal_id, pid])
|
|
|
|
cur.execute(
|
|
f"UPDATE goals SET {', '.join(updates)} WHERE id = %s AND profile_id = %s",
|
|
tuple(params)
|
|
)
|
|
|
|
return {"message": "Ziel aktualisiert"}
|
|
|
|
@router.delete("/{goal_id}")
|
|
def delete_goal(goal_id: str, session: dict = Depends(require_auth)):
|
|
"""Delete goal"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute(
|
|
"DELETE FROM goals WHERE id = %s AND profile_id = %s",
|
|
(goal_id, pid)
|
|
)
|
|
|
|
if cur.rowcount == 0:
|
|
raise HTTPException(status_code=404, detail="Ziel nicht gefunden")
|
|
|
|
return {"message": "Ziel gelöscht"}
|
|
|
|
# ============================================================================
|
|
# Training Phases
|
|
# ============================================================================
|
|
|
|
@router.get("/phases")
|
|
def list_training_phases(session: dict = Depends(require_auth)):
|
|
"""List training phases"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute("""
|
|
SELECT id, phase_type, detected_automatically, confidence_score,
|
|
status, start_date, end_date, duration_days,
|
|
detection_params, notes, created_at
|
|
FROM training_phases
|
|
WHERE profile_id = %s
|
|
ORDER BY start_date DESC
|
|
""", (pid,))
|
|
|
|
return [r2d(row) for row in cur.fetchall()]
|
|
|
|
@router.post("/phases")
|
|
def create_training_phase(data: TrainingPhaseCreate, session: dict = Depends(require_auth)):
|
|
"""Create training phase (manual)"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
|
|
duration = None
|
|
if data.end_date:
|
|
duration = (data.end_date - data.start_date).days
|
|
|
|
cur.execute("""
|
|
INSERT INTO training_phases (
|
|
profile_id, phase_type, detected_automatically,
|
|
status, start_date, end_date, duration_days, notes
|
|
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
|
|
RETURNING id
|
|
""", (
|
|
pid, data.phase_type, False,
|
|
'active', data.start_date, data.end_date, duration, data.notes
|
|
))
|
|
|
|
phase_id = cur.fetchone()['id']
|
|
|
|
return {"id": phase_id, "message": "Trainingsphase erstellt"}
|
|
|
|
@router.put("/phases/{phase_id}/status")
|
|
def update_phase_status(
|
|
phase_id: str,
|
|
status: str,
|
|
session: dict = Depends(require_auth)
|
|
):
|
|
"""Update training phase status (accept/reject auto-detected phases)"""
|
|
pid = session['profile_id']
|
|
|
|
valid_statuses = ['suggested', 'accepted', 'active', 'completed', 'rejected']
|
|
if status not in valid_statuses:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Ungültiger Status. Erlaubt: {', '.join(valid_statuses)}"
|
|
)
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute(
|
|
"UPDATE training_phases SET status = %s WHERE id = %s AND profile_id = %s",
|
|
(status, phase_id, pid)
|
|
)
|
|
|
|
if cur.rowcount == 0:
|
|
raise HTTPException(status_code=404, detail="Trainingsphase nicht gefunden")
|
|
|
|
return {"message": "Status aktualisiert"}
|
|
|
|
# ============================================================================
|
|
# Fitness Tests
|
|
# ============================================================================
|
|
|
|
@router.get("/tests")
|
|
def list_fitness_tests(session: dict = Depends(require_auth)):
|
|
"""List all fitness tests"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute("""
|
|
SELECT id, test_type, result_value, result_unit,
|
|
test_date, test_conditions, norm_category, created_at
|
|
FROM fitness_tests
|
|
WHERE profile_id = %s
|
|
ORDER BY test_date DESC
|
|
""", (pid,))
|
|
|
|
return [r2d(row) for row in cur.fetchall()]
|
|
|
|
@router.post("/tests")
|
|
def create_fitness_test(data: FitnessTestCreate, session: dict = Depends(require_auth)):
|
|
"""Record fitness test result"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
|
|
# Calculate norm category (simplified for now)
|
|
norm_category = _calculate_norm_category(
|
|
data.test_type,
|
|
data.result_value,
|
|
data.result_unit
|
|
)
|
|
|
|
cur.execute("""
|
|
INSERT INTO fitness_tests (
|
|
profile_id, test_type, result_value, result_unit,
|
|
test_date, test_conditions, norm_category
|
|
) VALUES (%s, %s, %s, %s, %s, %s, %s)
|
|
RETURNING id
|
|
""", (
|
|
pid, data.test_type, data.result_value, data.result_unit,
|
|
data.test_date, data.test_conditions, norm_category
|
|
))
|
|
|
|
test_id = cur.fetchone()['id']
|
|
|
|
return {"id": test_id, "norm_category": norm_category}
|
|
|
|
# ============================================================================
|
|
# Helper Functions
|
|
# ============================================================================
|
|
|
|
def _get_current_value_for_goal_type(conn, profile_id: str, goal_type: str) -> Optional[float]:
|
|
"""
|
|
Get current value for a goal type.
|
|
|
|
DEPRECATED: This function now delegates to the universal fetcher in goal_utils.py.
|
|
Phase 1.5: All goal types are now defined in goal_type_definitions table.
|
|
|
|
Args:
|
|
conn: Database connection
|
|
profile_id: User's profile ID
|
|
goal_type: Goal type key (e.g., 'weight', 'meditation_minutes')
|
|
|
|
Returns:
|
|
Current value or None
|
|
"""
|
|
# Delegate to universal fetcher (Phase 1.5)
|
|
return get_current_value_for_goal(conn, profile_id, goal_type)
|
|
|
|
def _update_goal_progress(conn, profile_id: str, goal: dict):
|
|
"""Update goal progress (modifies goal dict in-place)"""
|
|
# Get current value
|
|
current = _get_current_value_for_goal_type(conn, profile_id, goal['goal_type'])
|
|
|
|
if current is not None and goal['start_value'] is not None and goal['target_value'] is not None:
|
|
goal['current_value'] = current
|
|
|
|
# Calculate progress percentage
|
|
total_delta = float(goal['target_value']) - float(goal['start_value'])
|
|
current_delta = current - float(goal['start_value'])
|
|
|
|
if total_delta != 0:
|
|
progress_pct = (current_delta / total_delta) * 100
|
|
goal['progress_pct'] = round(progress_pct, 2)
|
|
|
|
# Simple linear projection
|
|
if goal['start_date'] and current_delta != 0:
|
|
days_elapsed = (date.today() - goal['start_date']).days
|
|
if days_elapsed > 0:
|
|
days_per_unit = days_elapsed / current_delta
|
|
remaining_units = float(goal['target_value']) - current
|
|
remaining_days = int(days_per_unit * remaining_units)
|
|
goal['projection_date'] = date.today() + timedelta(days=remaining_days)
|
|
|
|
# Check if on track
|
|
if goal['target_date'] and goal['projection_date']:
|
|
goal['on_track'] = goal['projection_date'] <= goal['target_date']
|
|
|
|
def _calculate_norm_category(test_type: str, value: float, unit: str) -> Optional[str]:
|
|
"""
|
|
Calculate norm category for fitness test
|
|
(Simplified - would need age/gender-specific norms)
|
|
"""
|
|
# Placeholder - should use proper norm tables
|
|
return None
|
|
|
|
# ============================================================================
|
|
# Goal Type Definitions (Phase 1.5 - Flexible Goal System)
|
|
# ============================================================================
|
|
|
|
@router.get("/schema-info")
|
|
def get_schema_info(session: dict = Depends(require_auth)):
|
|
"""
|
|
Get available tables and columns for goal type creation.
|
|
|
|
Admin-only endpoint for building custom goal types.
|
|
Returns structure with descriptions for UX guidance.
|
|
"""
|
|
pid = session['profile_id']
|
|
|
|
# Check admin role
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute("SELECT role FROM profiles WHERE id = %s", (pid,))
|
|
profile = cur.fetchone()
|
|
|
|
if not profile or profile['role'] != 'admin':
|
|
raise HTTPException(status_code=403, detail="Admin-Zugriff erforderlich")
|
|
|
|
# Define relevant tables with descriptions
|
|
# Only include tables that make sense for goal tracking
|
|
schema = {
|
|
"weight_log": {
|
|
"description": "Gewichtsverlauf",
|
|
"columns": {
|
|
"weight": {"type": "DECIMAL", "description": "Körpergewicht in kg"}
|
|
}
|
|
},
|
|
"caliper_log": {
|
|
"description": "Caliper-Messungen (Hautfalten)",
|
|
"columns": {
|
|
"body_fat_pct": {"type": "DECIMAL", "description": "Körperfettanteil in %"},
|
|
"sum_mm": {"type": "DECIMAL", "description": "Summe Hautfalten in mm"}
|
|
}
|
|
},
|
|
"circumference_log": {
|
|
"description": "Umfangsmessungen",
|
|
"columns": {
|
|
"c_neck": {"type": "DECIMAL", "description": "Nackenumfang in cm"},
|
|
"c_chest": {"type": "DECIMAL", "description": "Brustumfang in cm"},
|
|
"c_waist": {"type": "DECIMAL", "description": "Taillenumfang in cm"},
|
|
"c_hips": {"type": "DECIMAL", "description": "Hüftumfang in cm"},
|
|
"c_thigh_l": {"type": "DECIMAL", "description": "Oberschenkel links in cm"},
|
|
"c_thigh_r": {"type": "DECIMAL", "description": "Oberschenkel rechts in cm"},
|
|
"c_calf_l": {"type": "DECIMAL", "description": "Wade links in cm"},
|
|
"c_calf_r": {"type": "DECIMAL", "description": "Wade rechts in cm"},
|
|
"c_bicep_l": {"type": "DECIMAL", "description": "Bizeps links in cm"},
|
|
"c_bicep_r": {"type": "DECIMAL", "description": "Bizeps rechts in cm"}
|
|
}
|
|
},
|
|
"activity_log": {
|
|
"description": "Trainingseinheiten",
|
|
"columns": {
|
|
"id": {"type": "UUID", "description": "ID (für Zählung von Einheiten)"},
|
|
"duration_minutes": {"type": "INTEGER", "description": "Trainingsdauer in Minuten"},
|
|
"perceived_exertion": {"type": "INTEGER", "description": "Belastungsempfinden (1-10)"},
|
|
"quality_rating": {"type": "INTEGER", "description": "Qualitätsbewertung (1-10)"}
|
|
}
|
|
},
|
|
"nutrition_log": {
|
|
"description": "Ernährungstagebuch",
|
|
"columns": {
|
|
"calories": {"type": "INTEGER", "description": "Kalorien in kcal"},
|
|
"protein_g": {"type": "DECIMAL", "description": "Protein in g"},
|
|
"carbs_g": {"type": "DECIMAL", "description": "Kohlenhydrate in g"},
|
|
"fat_g": {"type": "DECIMAL", "description": "Fett in g"}
|
|
}
|
|
},
|
|
"sleep_log": {
|
|
"description": "Schlafprotokoll",
|
|
"columns": {
|
|
"total_minutes": {"type": "INTEGER", "description": "Gesamtschlafdauer in Minuten"}
|
|
}
|
|
},
|
|
"vitals_baseline": {
|
|
"description": "Vitalwerte (morgens)",
|
|
"columns": {
|
|
"resting_hr": {"type": "INTEGER", "description": "Ruhepuls in bpm"},
|
|
"hrv_rmssd": {"type": "INTEGER", "description": "Herzratenvariabilität (RMSSD) in ms"},
|
|
"vo2_max": {"type": "DECIMAL", "description": "VO2 Max in ml/kg/min"},
|
|
"spo2": {"type": "INTEGER", "description": "Sauerstoffsättigung in %"},
|
|
"respiratory_rate": {"type": "INTEGER", "description": "Atemfrequenz pro Minute"}
|
|
}
|
|
},
|
|
"blood_pressure_log": {
|
|
"description": "Blutdruckmessungen",
|
|
"columns": {
|
|
"systolic": {"type": "INTEGER", "description": "Systolischer Blutdruck in mmHg"},
|
|
"diastolic": {"type": "INTEGER", "description": "Diastolischer Blutdruck in mmHg"},
|
|
"pulse": {"type": "INTEGER", "description": "Puls in bpm"}
|
|
}
|
|
},
|
|
"rest_days": {
|
|
"description": "Ruhetage",
|
|
"columns": {
|
|
"id": {"type": "UUID", "description": "ID (für Zählung von Ruhetagen)"}
|
|
}
|
|
}
|
|
}
|
|
|
|
return schema
|
|
|
|
@router.get("/goal-types")
|
|
def list_goal_type_definitions(session: dict = Depends(require_auth)):
|
|
"""
|
|
Get all active goal type definitions.
|
|
|
|
Public endpoint - returns all available goal types for dropdown.
|
|
"""
|
|
try:
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
|
|
cur.execute("""
|
|
SELECT id, type_key, label_de, label_en, unit, icon, category,
|
|
source_table, source_column, aggregation_method,
|
|
calculation_formula, description, is_system, is_active,
|
|
created_at, updated_at
|
|
FROM goal_type_definitions
|
|
WHERE is_active = true
|
|
ORDER BY
|
|
CASE
|
|
WHEN is_system = true THEN 0
|
|
ELSE 1
|
|
END,
|
|
label_de
|
|
""")
|
|
|
|
results = [r2d(row) for row in cur.fetchall()]
|
|
print(f"[DEBUG] Loaded {len(results)} goal types")
|
|
return results
|
|
|
|
except Exception as e:
|
|
print(f"[ERROR] list_goal_type_definitions failed: {e}")
|
|
print(traceback.format_exc())
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Fehler beim Laden der Goal Types: {str(e)}"
|
|
)
|
|
|
|
@router.post("/goal-types")
|
|
def create_goal_type_definition(
|
|
data: GoalTypeCreate,
|
|
session: dict = Depends(require_auth)
|
|
):
|
|
"""
|
|
Create custom goal type definition.
|
|
|
|
Admin-only endpoint for creating new goal types.
|
|
Users with admin role can define custom metrics.
|
|
"""
|
|
pid = session['profile_id']
|
|
|
|
# Check admin role
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
cur.execute("SELECT role FROM profiles WHERE id = %s", (pid,))
|
|
profile = cur.fetchone()
|
|
|
|
if not profile or profile['role'] != 'admin':
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="Admin-Zugriff erforderlich"
|
|
)
|
|
|
|
# Validate type_key is unique
|
|
cur.execute(
|
|
"SELECT id FROM goal_type_definitions WHERE type_key = %s",
|
|
(data.type_key,)
|
|
)
|
|
if cur.fetchone():
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Goal Type '{data.type_key}' existiert bereits"
|
|
)
|
|
|
|
# Insert new goal type
|
|
import json as json_lib
|
|
filter_json = json_lib.dumps(data.filter_conditions) if data.filter_conditions else None
|
|
|
|
cur.execute("""
|
|
INSERT INTO goal_type_definitions (
|
|
type_key, label_de, label_en, unit, icon, category,
|
|
source_table, source_column, aggregation_method,
|
|
calculation_formula, filter_conditions, description, is_active, is_system
|
|
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
|
RETURNING id
|
|
""", (
|
|
data.type_key, data.label_de, data.label_en, data.unit, data.icon,
|
|
data.category, data.source_table, data.source_column,
|
|
data.aggregation_method, data.calculation_formula, filter_json, data.description,
|
|
True, False # is_active=True, is_system=False
|
|
))
|
|
|
|
goal_type_id = cur.fetchone()['id']
|
|
|
|
return {
|
|
"id": goal_type_id,
|
|
"message": f"Goal Type '{data.label_de}' erstellt"
|
|
}
|
|
|
|
@router.put("/goal-types/{goal_type_id}")
|
|
def update_goal_type_definition(
|
|
goal_type_id: str,
|
|
data: GoalTypeUpdate,
|
|
session: dict = Depends(require_auth)
|
|
):
|
|
"""
|
|
Update goal type definition.
|
|
|
|
Admin-only. System goal types can be updated but not deleted.
|
|
"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
|
|
# Check admin role
|
|
cur.execute("SELECT role FROM profiles WHERE id = %s", (pid,))
|
|
profile = cur.fetchone()
|
|
|
|
if not profile or profile['role'] != 'admin':
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="Admin-Zugriff erforderlich"
|
|
)
|
|
|
|
# Check goal type exists
|
|
cur.execute(
|
|
"SELECT id FROM goal_type_definitions WHERE id = %s",
|
|
(goal_type_id,)
|
|
)
|
|
if not cur.fetchone():
|
|
raise HTTPException(status_code=404, detail="Goal Type nicht gefunden")
|
|
|
|
# Build update query
|
|
updates = []
|
|
params = []
|
|
|
|
if data.label_de is not None:
|
|
updates.append("label_de = %s")
|
|
params.append(data.label_de)
|
|
|
|
if data.label_en is not None:
|
|
updates.append("label_en = %s")
|
|
params.append(data.label_en)
|
|
|
|
if data.unit is not None:
|
|
updates.append("unit = %s")
|
|
params.append(data.unit)
|
|
|
|
if data.icon is not None:
|
|
updates.append("icon = %s")
|
|
params.append(data.icon)
|
|
|
|
if data.category is not None:
|
|
updates.append("category = %s")
|
|
params.append(data.category)
|
|
|
|
if data.source_table is not None:
|
|
updates.append("source_table = %s")
|
|
params.append(data.source_table)
|
|
|
|
if data.source_column is not None:
|
|
updates.append("source_column = %s")
|
|
params.append(data.source_column)
|
|
|
|
if data.aggregation_method is not None:
|
|
updates.append("aggregation_method = %s")
|
|
params.append(data.aggregation_method)
|
|
|
|
if data.calculation_formula is not None:
|
|
updates.append("calculation_formula = %s")
|
|
params.append(data.calculation_formula)
|
|
|
|
if data.filter_conditions is not None:
|
|
import json as json_lib
|
|
filter_json = json_lib.dumps(data.filter_conditions) if data.filter_conditions else None
|
|
updates.append("filter_conditions = %s")
|
|
params.append(filter_json)
|
|
|
|
if data.description is not None:
|
|
updates.append("description = %s")
|
|
params.append(data.description)
|
|
|
|
if data.is_active is not None:
|
|
updates.append("is_active = %s")
|
|
params.append(data.is_active)
|
|
|
|
if not updates:
|
|
raise HTTPException(status_code=400, detail="Keine Änderungen angegeben")
|
|
|
|
updates.append("updated_at = NOW()")
|
|
params.append(goal_type_id)
|
|
|
|
cur.execute(
|
|
f"UPDATE goal_type_definitions SET {', '.join(updates)} WHERE id = %s",
|
|
tuple(params)
|
|
)
|
|
|
|
return {"message": "Goal Type aktualisiert"}
|
|
|
|
@router.delete("/goal-types/{goal_type_id}")
|
|
def delete_goal_type_definition(
|
|
goal_type_id: str,
|
|
session: dict = Depends(require_auth)
|
|
):
|
|
"""
|
|
Delete (deactivate) goal type definition.
|
|
|
|
Admin-only. System goal types cannot be deleted, only deactivated.
|
|
Custom goal types can be fully deleted if no goals reference them.
|
|
"""
|
|
pid = session['profile_id']
|
|
|
|
with get_db() as conn:
|
|
cur = get_cursor(conn)
|
|
|
|
# Check admin role
|
|
cur.execute("SELECT role FROM profiles WHERE id = %s", (pid,))
|
|
profile = cur.fetchone()
|
|
|
|
if not profile or profile['role'] != 'admin':
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="Admin-Zugriff erforderlich"
|
|
)
|
|
|
|
# Get goal type info
|
|
cur.execute(
|
|
"SELECT id, type_key, is_system FROM goal_type_definitions WHERE id = %s",
|
|
(goal_type_id,)
|
|
)
|
|
goal_type = cur.fetchone()
|
|
|
|
if not goal_type:
|
|
raise HTTPException(status_code=404, detail="Goal Type nicht gefunden")
|
|
|
|
# Check if any goals use this type
|
|
cur.execute(
|
|
"SELECT COUNT(*) as count FROM goals WHERE goal_type = %s",
|
|
(goal_type['type_key'],)
|
|
)
|
|
count = cur.fetchone()['count']
|
|
|
|
if count > 0:
|
|
# Deactivate instead of delete
|
|
cur.execute(
|
|
"UPDATE goal_type_definitions SET is_active = false WHERE id = %s",
|
|
(goal_type_id,)
|
|
)
|
|
return {
|
|
"message": f"Goal Type deaktiviert ({count} Ziele nutzen diesen Typ)"
|
|
}
|
|
else:
|
|
if goal_type['is_system']:
|
|
# System types: only deactivate
|
|
cur.execute(
|
|
"UPDATE goal_type_definitions SET is_active = false WHERE id = %s",
|
|
(goal_type_id,)
|
|
)
|
|
return {"message": "System Goal Type deaktiviert"}
|
|
else:
|
|
# Custom types: delete
|
|
cur.execute(
|
|
"DELETE FROM goal_type_definitions WHERE id = %s",
|
|
(goal_type_id,)
|
|
)
|
|
return {"message": "Goal Type gelöscht"}
|