Refactor code structure for improved readability and maintainability

2026-05-28 10:36:17 +05:00
commit d5a889ed6d
49 changed files with 6853 additions and 0 deletions
@@ -0,0 +1,412 @@
+import uuid
+from collections import defaultdict
+from datetime import UTC, datetime
+from typing import Annotated
+
+from fastapi import Depends, FastAPI, Header, HTTPException, Query, status
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session, selectinload
+
+from app.core import settings
+from app.db import SessionLocal, create_schema, get_db
+from app.models import Base, Equipment, Exercise, Workout, WorkoutItem, WorkoutSet
+from app.schemas import (
+    CaloriesRead,
+    EquipmentCreate,
+    EquipmentRead,
+    ExerciseCreate,
+    ExerciseRead,
+    ProgressionPoint,
+    ProgressionRead,
+    WorkoutCreate,
+    WorkoutItemCreate,
+    WorkoutItemRead,
+    WorkoutRead,
+    WorkoutSetCreate,
+    WorkoutSetRead,
+    WorkoutUpdate,
+)
+
+app = FastAPI(title="Train Watcher Logic Service", version="0.1.0")
+
+
+def require_service_token(x_service_token: Annotated[str | None, Header()] = None) -> None:
+    if x_service_token != settings.service_token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid service token",
+        )
+
+
+def get_user_id(x_user_id: Annotated[str | None, Header()] = None) -> uuid.UUID:
+    if not x_user_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Missing X-User-Id header",
+        )
+    try:
+        return uuid.UUID(x_user_id)
+    except ValueError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid X-User-Id",
+        ) from exc
+
+
+InternalAuth = Depends(require_service_token)
+Db = Annotated[Session, Depends(get_db)]
+CurrentUserId = Annotated[uuid.UUID, Depends(get_user_id)]
+
+
+@app.on_event("startup")
+def on_startup() -> None:
+    create_schema(Base.metadata)
+    with SessionLocal() as db:
+        seed_builtin_catalog(db)
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+def seed_builtin_catalog(db: Session) -> None:
+    exists = db.scalar(
+        select(func.count()).select_from(Equipment).where(Equipment.is_builtin.is_(True))
+    )
+    if exists:
+        return
+
+    treadmill = Equipment(
+        name="Беговая дорожка",
+        description="Кардио-тренажер для ходьбы и бега.",
+        is_builtin=True,
+    )
+    smith = Equipment(
+        name="Машина Смита",
+        description="Силовая рама с фиксированной траекторией грифа.",
+        is_builtin=True,
+    )
+    db.add_all([treadmill, smith])
+    db.flush()
+    db.add_all(
+        [
+            Exercise(
+                name="Жим лежа",
+                description="Базовое упражнение для груди, трицепса и передней дельты.",
+                is_builtin=True,
+                default_calories_per_minute=6,
+            ),
+            Exercise(
+                name="Приседания",
+                description="Базовое упражнение для ног и корпуса.",
+                is_builtin=True,
+                default_calories_per_minute=8,
+            ),
+            Exercise(
+                name="Бег",
+                description="Кардио-нагрузка на беговой дорожке.",
+                equipment_id=treadmill.id,
+                is_builtin=True,
+                default_calories_per_minute=10,
+            ),
+        ]
+    )
+    db.commit()
+
+
+def accessible_equipment(db: Session, user_id: uuid.UUID):
+    return select(Equipment).where(
+        (Equipment.is_builtin.is_(True)) | (Equipment.owner_user_id == user_id)
+    )
+
+
+def accessible_exercises(db: Session, user_id: uuid.UUID):
+    return select(Exercise).where(
+        (Exercise.is_builtin.is_(True)) | (Exercise.owner_user_id == user_id)
+    )
+
+
+@app.get(
+    "/internal/catalog/equipment",
+    dependencies=[InternalAuth],
+    response_model=list[EquipmentRead],
+)
+def list_equipment(db: Db, user_id: CurrentUserId, search: str | None = None) -> list[Equipment]:
+    statement = accessible_equipment(db, user_id).order_by(
+        Equipment.is_builtin.desc(), Equipment.name
+    )
+    if search:
+        statement = statement.where(Equipment.name.ilike(f"%{search}%"))
+    return list(db.scalars(statement))
+
+
+@app.post(
+    "/internal/catalog/equipment",
+    dependencies=[InternalAuth],
+    response_model=EquipmentRead,
+    status_code=status.HTTP_201_CREATED,
+)
+def create_equipment(payload: EquipmentCreate, db: Db, user_id: CurrentUserId) -> Equipment:
+    equipment = Equipment(owner_user_id=user_id, is_builtin=False, **payload.model_dump())
+    db.add(equipment)
+    db.commit()
+    db.refresh(equipment)
+    return equipment
+
+
+@app.get(
+    "/internal/catalog/exercises",
+    dependencies=[InternalAuth],
+    response_model=list[ExerciseRead],
+)
+def list_exercises(db: Db, user_id: CurrentUserId, search: str | None = None) -> list[Exercise]:
+    statement = accessible_exercises(db, user_id).order_by(
+        Exercise.is_builtin.desc(), Exercise.name
+    )
+    if search:
+        statement = statement.where(Exercise.name.ilike(f"%{search}%"))
+    return list(db.scalars(statement))
+
+
+@app.post(
+    "/internal/catalog/exercises",
+    dependencies=[InternalAuth],
+    response_model=ExerciseRead,
+    status_code=status.HTTP_201_CREATED,
+)
+def create_exercise(payload: ExerciseCreate, db: Db, user_id: CurrentUserId) -> Exercise:
+    if payload.equipment_id:
+        equipment = db.get(Equipment, payload.equipment_id)
+        if not equipment or (not equipment.is_builtin and equipment.owner_user_id != user_id):
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Equipment not found")
+    exercise = Exercise(owner_user_id=user_id, is_builtin=False, **payload.model_dump())
+    db.add(exercise)
+    db.commit()
+    db.refresh(exercise)
+    return exercise
+
+
+@app.get("/internal/workouts", dependencies=[InternalAuth], response_model=list[WorkoutRead])
+def list_workouts(db: Db, user_id: CurrentUserId) -> list[Workout]:
+    return list(
+        db.scalars(
+            select(Workout)
+            .where(Workout.user_id == user_id)
+            .options(selectinload(Workout.items).selectinload(WorkoutItem.sets))
+            .order_by(Workout.started_at.desc())
+        )
+    )
+
+
+@app.post(
+    "/internal/workouts",
+    dependencies=[InternalAuth],
+    response_model=WorkoutRead,
+    status_code=status.HTTP_201_CREATED,
+)
+def create_workout(payload: WorkoutCreate, db: Db, user_id: CurrentUserId) -> Workout:
+    workout = Workout(
+        user_id=user_id,
+        started_at=payload.started_at or datetime.now(UTC),
+        notes=payload.notes,
+    )
+    db.add(workout)
+    db.commit()
+    db.refresh(workout)
+    return workout
+
+
+@app.get("/internal/workouts/{workout_id}", dependencies=[InternalAuth], response_model=WorkoutRead)
+def get_workout(workout_id: uuid.UUID, db: Db, user_id: CurrentUserId) -> Workout:
+    workout = db.scalar(
+        select(Workout)
+        .where(Workout.id == workout_id, Workout.user_id == user_id)
+        .options(selectinload(Workout.items).selectinload(WorkoutItem.sets))
+    )
+    if not workout:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Workout not found")
+    return workout
+
+
+@app.patch(
+    "/internal/workouts/{workout_id}",
+    dependencies=[InternalAuth],
+    response_model=WorkoutRead,
+)
+def update_workout(
+    workout_id: uuid.UUID, payload: WorkoutUpdate, db: Db, user_id: CurrentUserId
+) -> Workout:
+    workout = get_workout(workout_id, db, user_id)
+    if payload.finished_at is not None:
+        workout.finished_at = payload.finished_at
+    if payload.notes is not None:
+        workout.notes = payload.notes
+    recalculate_workout_calories(db, workout.id)
+    db.commit()
+    db.refresh(workout)
+    return workout
+
+
+@app.post(
+    "/internal/workouts/{workout_id}/items",
+    dependencies=[InternalAuth],
+    response_model=WorkoutItemRead,
+    status_code=status.HTTP_201_CREATED,
+)
+def add_workout_item(
+    workout_id: uuid.UUID, payload: WorkoutItemCreate, db: Db, user_id: CurrentUserId
+) -> WorkoutItem:
+    workout = get_workout(workout_id, db, user_id)
+    if payload.exercise_id:
+        exercise = db.get(Exercise, payload.exercise_id)
+        if not exercise or (not exercise.is_builtin and exercise.owner_user_id != user_id):
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Exercise not found")
+    if payload.equipment_id:
+        equipment = db.get(Equipment, payload.equipment_id)
+        if not equipment or (not equipment.is_builtin and equipment.owner_user_id != user_id):
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Equipment not found")
+
+    next_index = payload.order_index
+    if next_index is None:
+        next_index = len(workout.items)
+    item = WorkoutItem(
+        workout_id=workout.id,
+        **payload.model_dump(exclude={"order_index"}),
+        order_index=next_index,
+    )
+    db.add(item)
+    db.commit()
+    db.refresh(item)
+    return item
+
+
+@app.post(
+    "/internal/workout-items/{item_id}/sets",
+    dependencies=[InternalAuth],
+    response_model=WorkoutSetRead,
+    status_code=status.HTTP_201_CREATED,
+)
+def add_workout_set(
+    item_id: uuid.UUID,
+    payload: WorkoutSetCreate,
+    db: Db,
+    user_id: CurrentUserId,
+) -> WorkoutSet:
+    item = db.scalar(
+        select(WorkoutItem)
+        .join(Workout)
+        .where(WorkoutItem.id == item_id, Workout.user_id == user_id)
+        .options(selectinload(WorkoutItem.sets), selectinload(WorkoutItem.exercise))
+    )
+    if not item:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Workout item not found")
+
+    calories = payload.calories
+    if calories is None:
+        calories = estimate_set_calories(item, payload)
+
+    workout_set = WorkoutSet(
+        workout_item_id=item.id,
+        set_index=len(item.sets) + 1,
+        weight=payload.weight,
+        reps=payload.reps,
+        duration_seconds=payload.duration_seconds,
+        calories=calories,
+        completed_at=payload.completed_at or datetime.now(UTC),
+    )
+    db.add(workout_set)
+    db.flush()
+    recalculate_workout_calories(db, item.workout_id)
+    db.commit()
+    db.refresh(workout_set)
+    return workout_set
+
+
+def estimate_set_calories(item: WorkoutItem, payload: WorkoutSetCreate) -> float:
+    if item.exercise and item.exercise.default_calories_per_minute and payload.duration_seconds:
+        return round(
+            float(item.exercise.default_calories_per_minute) * payload.duration_seconds / 60,
+            2,
+        )
+    return round((payload.weight * max(payload.reps, 1)) / 120, 2)
+
+
+def recalculate_workout_calories(db: Session, workout_id: uuid.UUID) -> None:
+    total = db.scalar(
+        select(func.coalesce(func.sum(WorkoutSet.calories), 0))
+        .join(WorkoutItem, WorkoutSet.workout_item_id == WorkoutItem.id)
+        .where(WorkoutItem.workout_id == workout_id)
+    )
+    workout = db.get(Workout, workout_id)
+    if workout:
+        workout.estimated_calories = float(total or 0)
+
+
+@app.get(
+    "/internal/analytics/progression",
+    dependencies=[InternalAuth],
+    response_model=ProgressionRead,
+)
+def get_progression(
+    db: Db,
+    user_id: CurrentUserId,
+    kind: str = Query(pattern="^(exercise|equipment)$"),
+    entity_id: uuid.UUID | None = None,
+) -> ProgressionRead:
+    statement = (
+        select(Workout.started_at, WorkoutSet.weight, WorkoutSet.reps)
+        .join(WorkoutItem, WorkoutSet.workout_item_id == WorkoutItem.id)
+        .join(Workout, WorkoutItem.workout_id == Workout.id)
+        .where(Workout.user_id == user_id)
+        .order_by(Workout.started_at.asc(), WorkoutSet.completed_at.asc())
+    )
+    if entity_id and kind == "exercise":
+        statement = statement.where(WorkoutItem.exercise_id == entity_id)
+    elif entity_id and kind == "equipment":
+        statement = statement.where(WorkoutItem.equipment_id == entity_id)
+
+    rows = list(db.execute(statement))
+    grouped: dict[str, dict[str, float]] = defaultdict(lambda: {"max_weight": 0, "volume": 0})
+    weights: list[float] = []
+    for started_at, weight, reps in rows:
+        date_key = started_at.date().isoformat()
+        numeric_weight = float(weight or 0)
+        grouped[date_key]["max_weight"] = max(grouped[date_key]["max_weight"], numeric_weight)
+        grouped[date_key]["volume"] += numeric_weight * int(reps or 0)
+        weights.append(numeric_weight)
+
+    points = [
+        ProgressionPoint(date=date, max_weight=values["max_weight"], volume=values["volume"])
+        for date, values in sorted(grouped.items())
+    ]
+    previous_delta = None
+    if len(weights) >= 2:
+        previous_delta = round(weights[-1] - weights[-2], 2)
+    return ProgressionRead(
+        last_weight=weights[-1] if weights else None,
+        max_weight=max(weights) if weights else None,
+        previous_delta=previous_delta,
+        points=points,
+    )
+
+
+@app.get("/internal/analytics/calories", dependencies=[InternalAuth], response_model=CaloriesRead)
+def get_calories(db: Db, user_id: CurrentUserId) -> CaloriesRead:
+    workouts = list(
+        db.scalars(
+            select(Workout).where(Workout.user_id == user_id).order_by(Workout.started_at.desc())
+        )
+    )
+    total = sum(float(workout.estimated_calories or 0) for workout in workouts)
+    return CaloriesRead(
+        total_calories=round(total, 2),
+        workouts=[
+            {
+                "id": str(workout.id),
+                "date": workout.started_at.date().isoformat(),
+                "calories": float(workout.estimated_calories or 0),
+            }
+            for workout in workouts
+        ],
+    )