Add trend-range gating, vehicle filter, sync cancel, moving time, and UI fixes

- Grey out trend ranges beyond available health history
- Reject implausibly fast (vehicle) activities on upload with feedback
- Add cancel button + cooperative cancellation for Garmin sync
- Show daily steps prominently on the dashboard
- Clear errors for malformed/empty upload ZIPs
- Snap-target dot when drawing a segment on the map
- Time-axis fallback for stationary/HIIT HR timelines; hide map when no GPS
- Parse and display moving time (timer) vs elapsed; backfill task
- Restyle SegmentsPanel like RouteLeaderboard; Laps/Routes/Segments on one row

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

backend/app/api/activities.py

@@ -35,6 +35,7 @@ class ActivitySummary(BaseModel):
 
 class ActivityDetail(ActivitySummary):
     end_time: Optional[datetime]
+    moving_time_s: Optional[float]
     elevation_loss_m: Optional[float]
     max_heart_rate: Optional[float]
     avg_power: Optional[float]

backend/app/api/garmin_sync.py

@@ -13,6 +13,19 @@ from app.models.user import User, GarminConnectConfig
 router = APIRouter()
 
 
+def _redis_client():
+    import redis as redis_lib
+    return redis_lib.Redis.from_url(settings.redis_url)
+
+
+def sync_task_key(user_id: int) -> str:
+    return f"garmin_sync_task:{user_id}"
+
+
+def sync_cancel_key(user_id: int) -> str:
+    return f"garmin_sync_cancel:{user_id}"
+
+
 class GarminConfigIn(BaseModel):
     email: str
     password: Optional[str] = None       # plaintext; encrypted before storage. None = keep existing.
@@ -183,4 +196,47 @@ async def trigger_sync(
 
     from app.workers.tasks import sync_garmin_connect_user
     task = sync_garmin_connect_user.delay(current_user.id)
+
+    # Track the active task id and clear any stale cancel flag so the new sync runs.
+    try:
+        r = _redis_client()
+        r.delete(sync_cancel_key(current_user.id))
+        r.set(sync_task_key(current_user.id), task.id, ex=3600)
+    except Exception:
+        pass
+
     return {"task_id": task.id, "status": "queued"}
+
+
+@router.post("/cancel")
+async def cancel_sync(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Request cancellation of the user's in-progress Garmin sync. The running task
+    checks this flag between items and aborts cooperatively."""
+    from app.workers.tasks import celery_app
+
+    try:
+        r = _redis_client()
+        r.set(sync_cancel_key(current_user.id), "1", ex=3600)
+        task_id = r.get(sync_task_key(current_user.id))
+        if task_id:
+            tid = task_id.decode() if isinstance(task_id, (bytes, bytearray)) else task_id
+            # terminate=False: don't kill a running worker mid-transaction; the
+            # cooperative flag handles an already-running task, and this revoke
+            # prevents a still-queued one from starting.
+            celery_app.control.revoke(tid, terminate=False)
+    except Exception:
+        pass
+
+    # Reflect intent immediately so the UI updates before the worker writes "Cancelled".
+    result = await db.execute(
+        select(GarminConnectConfig).where(GarminConnectConfig.user_id == current_user.id)
+    )
+    cfg = result.scalar_one_or_none()
+    if cfg:
+        cfg.last_sync_status = "Cancelling…"
+        await db.commit()
+
+    return {"status": "cancelling"}

backend/app/api/upload.py

@@ -115,14 +115,21 @@ async def upload_garmin_export(
     extract_dir = dest_dir / f"garmin_{dest.stem}"
 
     task_ids = []
-    with zipfile.ZipFile(dest) as zf:
-        extracted = _safe_extract(zf, extract_dir)
+    try:
+        with zipfile.ZipFile(dest) as zf:
+            extracted = _safe_extract(zf, extract_dir)
+    except zipfile.BadZipFile:
+        dest.unlink(missing_ok=True)
+        raise HTTPException(status_code=400, detail="Uploaded file is not a valid ZIP archive")
 
+    has_health = False
     for path in extracted:
         suffix = path.suffix.lower()
         if suffix == ".fit":
             task = process_activity_file.delay(str(path), current_user.id, "fit")
             task_ids.append(task.id)
+        elif suffix == ".json":
+            has_health = True   # Garmin wellness data is exported as JSON files
         elif suffix == ".zip":
             # Garmin exports nest activity FIT files inside sub-zips
             # (e.g. DI-Connect-Uploaded-Files/UploadedFiles_*_Part*.zip)
@@ -137,6 +144,12 @@ async def upload_garmin_export(
                     task = process_activity_file.delay(str(np), current_user.id, "fit")
                     task_ids.append(task.id)
 
+    if not task_ids and not has_health:
+        raise HTTPException(
+            status_code=400,
+            detail="No fitness data found in this archive — make sure you uploaded your full Garmin Connect export ZIP",
+        )
+
     # Queue health/wellness data extraction
     health_task = process_garmin_health_zip.delay(str(dest), current_user.id)
 
@@ -163,8 +176,12 @@ async def upload_strava_export(
     extract_dir = dest_dir / f"strava_{dest.stem}"
 
     task_ids = []
-    with zipfile.ZipFile(dest) as zf:
-        extracted = _safe_extract(zf, extract_dir)
+    try:
+        with zipfile.ZipFile(dest) as zf:
+            extracted = _safe_extract(zf, extract_dir)
+    except zipfile.BadZipFile:
+        dest.unlink(missing_ok=True)
+        raise HTTPException(status_code=400, detail="Uploaded file is not a valid ZIP archive")
 
     for path in extracted:
         suffix = path.suffix.lower()
@@ -172,6 +189,12 @@ async def upload_strava_export(
             task = process_activity_file.delay(str(path), current_user.id, suffix[1:])
             task_ids.append(task.id)
 
+    if not task_ids:
+        raise HTTPException(
+            status_code=400,
+            detail="No activity files (.fit or .gpx) found in this Strava archive",
+        )
+
     return {
         "status": "queued",
         "activity_tasks": len(task_ids),

backend/app/main.py

@@ -50,6 +50,15 @@ async def init_db():
     except Exception as e:
         print(f"Column migration skipped: {e}")
 
+    # activities.moving_time_s column added after initial creation (timer time)
+    try:
+        async with engine.begin() as conn:
+            await conn.execute(text(
+                "ALTER TABLE activities ADD COLUMN IF NOT EXISTS moving_time_s FLOAT"
+            ))
+    except Exception as e:
+        print(f"activities.moving_time_s column migration skipped: {e}")
+
     # health_metrics columns added after initial creation
     try:
         async with engine.begin() as conn:

backend/app/models/user.py

@@ -92,7 +92,8 @@ class Activity(Base):
     start_time = Column(DateTime(timezone=True), nullable=False, index=True)
     end_time = Column(DateTime(timezone=True), nullable=True)
     distance_m = Column(Float, nullable=True)
-    duration_s = Column(Float, nullable=True)
+    duration_s = Column(Float, nullable=True)          # total elapsed time (wall clock, incl. pauses)
+    moving_time_s = Column(Float, nullable=True)        # timer time — excludes paused periods
     elevation_gain_m = Column(Float, nullable=True)
     elevation_loss_m = Column(Float, nullable=True)
     avg_heart_rate = Column(Float, nullable=True)

backend/app/services/fit_parser.py

@@ -44,6 +44,33 @@ def _sanitize_speed(val, dist_m=None, dur_s=None) -> Optional[float]:
     return fv
 
 
+# Conservative average-speed ceilings (m/s) above which an activity was almost
+# certainly recorded in a vehicle rather than under human power. Sports not
+# listed fall back to the generous default.
+_VEHICLE_SPEED_CEILINGS = {
+    "running": 8.0,    # ~28.8 km/h — well above elite sprint pace sustained
+    "walking": 8.0,
+    "hiking": 8.0,
+    "cycling": 22.0,   # ~79 km/h — beyond sustained amateur cycling
+}
+_VEHICLE_SPEED_DEFAULT = 25.0   # ~90 km/h
+
+
+def _vehicle_reason(sport_type, avg_speed_ms, dist_m=None, dur_s=None) -> Optional[str]:
+    """Return a human-readable reason if the average speed is implausibly fast for
+    the sport (i.e. the 'activity' looks like car/vehicle travel), else None."""
+    speed = _safe_float(avg_speed_ms)
+    if speed is None and dist_m and dur_s and float(dur_s) > 0:
+        speed = float(dist_m) / float(dur_s)
+    if speed is None or speed <= 0:
+        return None
+    ceiling = _VEHICLE_SPEED_CEILINGS.get(sport_type, _VEHICLE_SPEED_DEFAULT)
+    if speed > ceiling:
+        return (f"Looks like vehicle travel — average speed {speed * 3.6:.0f} km/h "
+                f"exceeds the plausible limit for {sport_type}")
+    return None
+
+
 def _bounding_box(coords):
     if not coords:
         return None
@@ -210,12 +237,22 @@ def parse_fit_file(filepath: str) -> dict:
     if start_time:
         name += " " + start_time.strftime("%Y-%m-%d")
 
+    total_dist = _safe_float(get(session_data, "totalDistance", "total_distance"))
+    elapsed_s = _safe_float(get(session_data, "totalElapsedTime", "total_elapsed_time"))
+    # Timer time = time the device was actively recording (excludes auto/manual pauses).
+    moving_s = _safe_float(get(session_data, "totalTimerTime", "total_timer_time"))
+    avg_speed = _sanitize_speed(
+        get(session_data, "avgSpeed", "avg_speed", "enhancedAvgSpeed", "enhanced_avg_speed"),
+        dist_m=total_dist, dur_s=elapsed_s,
+    )
+
     return {
         "name": name,
         "sport_type": sport_type,
         "start_time": start_time.isoformat() if start_time else None,
-        "distance_m": _safe_float(get(session_data, "totalDistance", "total_distance")),
-        "duration_s": _safe_float(get(session_data, "totalElapsedTime", "total_elapsed_time")),
+        "distance_m": total_dist,
+        "duration_s": elapsed_s,
+        "moving_time_s": moving_s,
         "elevation_gain_m": _safe_float(get(session_data, "totalAscent", "total_ascent")),
         "elevation_loss_m": _safe_float(get(session_data, "totalDescent", "total_descent")),
         "avg_heart_rate": _safe_float(get(session_data, "avgHeartRate", "avg_heart_rate")),
@@ -223,11 +260,7 @@ def parse_fit_file(filepath: str) -> dict:
         "avg_cadence": _safe_float(get(session_data, "avgCadence", "avg_cadence")),
         "avg_power": _safe_float(get(session_data, "avgPower", "avg_power")),
         "normalized_power": _safe_float(get(session_data, "normalizedPower", "normalized_power")),
-        "avg_speed_ms": _sanitize_speed(
-            get(session_data, "avgSpeed", "avg_speed", "enhancedAvgSpeed", "enhanced_avg_speed"),
-            dist_m=_safe_float(get(session_data, "totalDistance", "total_distance")),
-            dur_s=_safe_float(get(session_data, "totalElapsedTime", "total_elapsed_time")),
-        ),
+        "avg_speed_ms": avg_speed,
         "max_speed_ms": _safe_float(get(session_data, "maxSpeed", "max_speed",
                                         "enhancedMaxSpeed", "enhanced_max_speed")),
         "avg_temperature_c": _safe_float(get(session_data, "avgTemperature", "avg_temperature")),
@@ -239,6 +272,7 @@ def parse_fit_file(filepath: str) -> dict:
         "polyline": encoded_polyline,
         "bounding_box": bounding_box,
         "source_type": "fit",
+        "rejected_reason": _vehicle_reason(sport_type, avg_speed, total_dist, moving_s or elapsed_s),
         "data_points": normalized_points,
         "laps": normalized_laps,
     }
@@ -310,20 +344,23 @@ def parse_gpx_file(filepath: str) -> dict:
     end_dt = datetime.fromisoformat(data_points[-1]["timestamp"]) if data_points else None
     duration = (end_dt - start_dt).total_seconds() if (start_dt and end_dt) else None
     sport = track.type.lower() if track.type else "running"
+    gpx_avg_speed = (total_dist / duration) if (total_dist and duration) else None
 
     return {
         "name": track.name or gpx.name or f"Activity {start_dt.date() if start_dt else ''}",
         "sport_type": sport, "start_time": start_time_str,
-        "distance_m": total_dist, "duration_s": duration,
+        "distance_m": total_dist, "duration_s": duration, "moving_time_s": None,
         "elevation_gain_m": uphill, "elevation_loss_m": downhill,
         "avg_heart_rate": (sum(hrs) / len(hrs)) if hrs else None,
         "max_heart_rate": max(hrs) if hrs else None,
         "avg_cadence": None, "avg_power": None, "normalized_power": None,
-        "avg_speed_ms": (total_dist / duration) if (total_dist and duration) else None,
+        "avg_speed_ms": gpx_avg_speed,
         "max_speed_ms": None, "avg_temperature_c": None, "calories": None,
         "training_stress_score": None, "vo2max_estimate": None,
         "polyline": encoded_polyline, "bounding_box": bounding_box,
-        "source_type": "gpx", "data_points": data_points, "laps": [],
+        "source_type": "gpx",
+        "rejected_reason": _vehicle_reason(sport, gpx_avg_speed, total_dist, duration),
+        "data_points": data_points, "laps": [],
     }
 
 

backend/app/workers/tasks.py

@@ -80,6 +80,11 @@ def process_activity_file(self, file_path: str, user_id: int, source_type: str,
     if not parsed.get("start_time"):
         return {"status": "skipped", "reason": "no start_time", "file": file_path}
 
+    # Reject activities whose average speed is implausible for the sport (e.g. a
+    # car journey accidentally recorded). Surfaced to the upload UI as the reason.
+    if parsed.get("rejected_reason"):
+        return {"status": "skipped", "reason": parsed["rejected_reason"], "file": file_path}
+
     with SyncSessionLocal() as db:
         start_time = datetime.fromisoformat(parsed["start_time"])
 
@@ -128,6 +133,7 @@ def process_activity_file(self, file_path: str, user_id: int, source_type: str,
             start_time=start_time,
             distance_m=parsed.get("distance_m"),
             duration_s=parsed.get("duration_s"),
+            moving_time_s=parsed.get("moving_time_s"),
             elevation_gain_m=parsed.get("elevation_gain_m"),
             elevation_loss_m=parsed.get("elevation_loss_m"),
             avg_heart_rate=parsed.get("avg_heart_rate"),
@@ -651,6 +657,10 @@ def process_garmin_health_zip(zip_path: str, user_id: int):
         db.commit()
 
 
+class SyncCancelled(Exception):
+    """Raised inside a Garmin sync when the user has requested cancellation."""
+
+
 @celery_app.task(name="sync_garmin_connect_user")
 def sync_garmin_connect_user(user_id: int):
     """Sync Garmin Connect data (activities + wellness) for one user."""
@@ -661,6 +671,20 @@ def sync_garmin_connect_user(user_id: int):
     from sqlalchemy import select
     from datetime import datetime, timezone
 
+    # Cooperative-cancellation flag (set by POST /garmin-sync/cancel).
+    cancel_key = f"garmin_sync_cancel:{user_id}"
+    try:
+        import redis as redis_lib
+        _redis = redis_lib.Redis.from_url(settings.redis_url)
+    except Exception:
+        _redis = None
+
+    def _cancelled():
+        try:
+            return bool(_redis and _redis.exists(cancel_key))
+        except Exception:
+            return False
+
     with SyncSessionLocal() as db:
         cfg = db.execute(
             select(GarminConnectConfig).where(GarminConnectConfig.user_id == user_id)
@@ -698,31 +722,51 @@ def sync_garmin_connect_user(user_id: int):
         errors = []
 
         def _set_status(text):
+            # Checked between items: abort the sync if cancellation was requested.
+            if _cancelled():
+                raise SyncCancelled()
             cfg.last_sync_status = text
             db.commit()
 
-        if sync_acts:
-            _set_status("Syncing activities...")
-            try:
-                activities_queued = sync_activities(
-                    garmin, user_id, last_sync_at, db, settings.file_store_path,
-                    lookback_days=lookback,
-                    status_callback=_set_status,
-                )
-            except Exception as exc:
-                errors.append(f"activities: {exc}")
+        try:
+            if sync_acts:
+                _set_status("Syncing activities...")
+                try:
+                    activities_queued = sync_activities(
+                        garmin, user_id, last_sync_at, db, settings.file_store_path,
+                        lookback_days=lookback,
+                        status_callback=_set_status,
+                    )
+                except SyncCancelled:
+                    raise
+                except Exception as exc:
+                    errors.append(f"activities: {exc}")
 
-        if sync_well:
-            _set_status("Syncing wellness...")
+            if sync_well:
+                _set_status("Syncing wellness...")
+                try:
+                    wellness_days = sync_wellness(
+                        garmin, user_id, last_sync_at, db,
+                        lookback_days=lookback,
+                        status_callback=_set_status,
+                    )
+                except SyncCancelled:
+                    raise
+                except Exception as exc:
+                    errors.append(f"wellness: {exc}")
+                    db.rollback()  # recover session so the final status commit can succeed
+        except SyncCancelled:
+            db.rollback()
+            cfg.last_sync_at = datetime.now(timezone.utc)
+            cfg.last_sync_status = "Cancelled"
+            db.commit()
             try:
-                wellness_days = sync_wellness(
-                    garmin, user_id, last_sync_at, db,
-                    lookback_days=lookback,
-                    status_callback=_set_status,
-                )
-            except Exception as exc:
-                errors.append(f"wellness: {exc}")
-                db.rollback()  # recover session so the final status commit can succeed
+                if _redis:
+                    _redis.delete(cancel_key)
+            except Exception:
+                pass
+            return {"status": "cancelled",
+                    "activities_queued": activities_queued, "wellness_days": wellness_days}
 
         cfg.last_sync_at = datetime.now(timezone.utc)
         cfg.last_sync_status = (
@@ -777,3 +821,47 @@ def recalculate_hr_zones_for_user(user_id: int, new_max_hr: float):
                 activity.hr_zones = new_zones
 
         db.commit()
+
+
+@celery_app.task(name="backfill_moving_time")
+def backfill_moving_time(user_id: int = None):
+    """Populate moving_time_s for existing FIT-sourced activities by re-reading the
+    timer time from their stored source files. Idempotent — skips activities that
+    already have a value or whose source file is missing/unreadable."""
+    import os
+    from app.services.fit_parser import parse_fit_file
+    from app.core.database import SyncSessionLocal
+    from app.models.user import Activity
+    from sqlalchemy import select
+
+    updated, skipped = 0, 0
+    with SyncSessionLocal() as db:
+        q = select(Activity).where(
+            Activity.moving_time_s.is_(None),
+            Activity.source_type == "fit",
+            Activity.source_file.isnot(None),
+        )
+        if user_id is not None:
+            q = q.where(Activity.user_id == user_id)
+        activities = db.execute(q).scalars().all()
+
+        for activity in activities:
+            path = activity.source_file
+            if not path or not os.path.exists(path):
+                skipped += 1
+                continue
+            try:
+                parsed = parse_fit_file(path)
+            except Exception:
+                skipped += 1
+                continue
+            mt = parsed.get("moving_time_s")
+            if mt:
+                activity.moving_time_s = mt
+                updated += 1
+            else:
+                skipped += 1
+
+        db.commit()
+
+    return {"status": "ok", "updated": updated, "skipped": skipped}