fix

backend/app/services/fit_parser.py

@@ -7,14 +7,30 @@ import fitdecode
 from backend.app.models.activity import Activity, DataPoint
 
 
+# Map FIT sport enum values to human-readable names
+SPORT_NAMES = {
+    "cycling": "Cycling",
+    "running": "Running",
+    "swimming": "Swimming",
+    "training": "Strength",
+    "strength_training": "Strength",
+    "cardio_training": "Cardio",
+    "walking": "Walking",
+    "hiking": "Hiking",
+    "generic": "Workout",
+}
+
+
 def parse_fit_file(
     file_content: bytes,
     rider_id: uuid.UUID,
     file_path: str,
-) -> tuple[Activity, list[DataPoint]]:
-    """Parse a .FIT file and return an Activity with its DataPoints."""
+) -> tuple[Activity, list[DataPoint], list[dict]]:
+    """Parse a .FIT file and return an Activity with its DataPoints and exercise sets."""
     data_points: list[DataPoint] = []
     session_data: dict = {}
+    exercise_sets: list[dict] = []
+    current_exercise: str | None = None
 
     with fitdecode.FitReader(BytesIO(file_content)) as fit:
         for frame in fit:
@@ -29,14 +45,43 @@ def parse_fit_file(
             elif frame.name == "session":
                 session_data = _parse_session(frame)
 
-    start_time = data_points[0].timestamp if data_points else datetime.now(timezone.utc)
-    end_time = data_points[-1].timestamp if data_points else start_time
-    duration = int((end_time - start_time).total_seconds()) if data_points else 0
+            elif frame.name == "workout":
+                # Workout-level info (name etc.)
+                wkt_name = _get_field_str(frame, "wkt_name")
+                if wkt_name:
+                    session_data.setdefault("workout_name", wkt_name)
+
+            elif frame.name == "exercise_title":
+                title = _get_field_str(frame, "exercise_name")
+                if title:
+                    current_exercise = title
+
+            elif frame.name == "set":
+                ex_set = _parse_set(frame, current_exercise)
+                if ex_set:
+                    exercise_sets.append(ex_set)
+
+    # Determine timing
+    sport = session_data.get("sport", "")
+    sport_name = SPORT_NAMES.get(sport.lower() if sport else "", sport or "Workout")
+
+    if data_points:
+        start_time = data_points[0].timestamp
+        end_time = data_points[-1].timestamp
+        duration = int((end_time - start_time).total_seconds())
+    else:
+        # No record data (strength, etc.) — use session timestamps
+        start_time = session_data.get("start_time") or datetime.now(timezone.utc)
+        elapsed = session_data.get("total_elapsed_time")
+        duration = int(elapsed) if elapsed else 0
+        end_time = start_time
+
+    name = session_data.get("workout_name") or sport_name
 
     activity = Activity(
         rider_id=rider_id,
-        name=session_data.get("sport", "Ride"),
-        activity_type=session_data.get("sub_sport", "road"),
+        name=name,
+        activity_type=session_data.get("sub_sport") or sport or "generic",
         date=start_time,
         duration=duration,
         distance=session_data.get("total_distance"),
@@ -44,7 +89,7 @@ def parse_fit_file(
         file_path=file_path,
     )
 
-    return activity, data_points
+    return activity, data_points, exercise_sets
 
 
 def _parse_record(frame: fitdecode.FitDataMessage) -> DataPoint | None:
@@ -71,12 +116,44 @@ def _parse_record(frame: fitdecode.FitDataMessage) -> DataPoint | None:
 
 def _parse_session(frame: fitdecode.FitDataMessage) -> dict:
     """Extract session-level data from FIT session message."""
+    start_time = _get_field(frame, "start_time")
+    if isinstance(start_time, datetime) and start_time.tzinfo is None:
+        start_time = start_time.replace(tzinfo=timezone.utc)
+
     return {
         "sport": _get_field_str(frame, "sport"),
         "sub_sport": _get_field_str(frame, "sub_sport"),
         "total_distance": _get_field(frame, "total_distance"),
         "total_ascent": _get_field(frame, "total_ascent"),
         "total_elapsed_time": _get_field(frame, "total_elapsed_time"),
+        "total_calories": _get_field(frame, "total_calories"),
+        "avg_heart_rate": _get_field(frame, "avg_heart_rate"),
+        "max_heart_rate": _get_field(frame, "max_heart_rate"),
+        "start_time": start_time,
+    }
+
+
+def _parse_set(frame: fitdecode.FitDataMessage, exercise_name: str | None) -> dict | None:
+    """Parse a set message from a strength/cardio workout."""
+    set_type = _get_field_str(frame, "set_type")
+    # set_type: 0=active, 1=rest
+    if set_type is not None and str(set_type) in ("1", "rest"):
+        return None  # Skip rest sets
+
+    repetitions = _get_field(frame, "repetitions")
+    weight = _get_field(frame, "weight")
+    duration = _get_field(frame, "duration")
+    start_time = _get_field(frame, "start_time") or _get_field(frame, "timestamp")
+    category = _get_field_str(frame, "exercise_category")
+    exercise = _get_field_str(frame, "exercise_name")
+
+    return {
+        "exercise_name": exercise or exercise_name or category or "Unknown",
+        "exercise_category": category,
+        "repetitions": int(repetitions) if repetitions is not None else None,
+        "weight": round(float(weight), 1) if weight is not None else None,
+        "duration": round(float(duration), 1) if duration is not None else None,
+        "start_time": start_time.isoformat() if isinstance(start_time, datetime) else None,
     }