feat: Save Strava activities without routes

2 files changed, 101 insertions, 16 deletions

diff --git a/web/server.go b/web/server.go
index 6f222ef..46fe66b 100644
--- a/web/server.go
+++ b/web/server.go
@@ -89,6 +89,11 @@ func (s *Server) handleRide(w http.ResponseWriter, r *http.Request) {
 		http.NotFound(w, r)
 		return
 	}
+	if item.GPXPath == "" {
+		slog.Info("Loaded ride detail without route", "ride_id", id)
+		kcore.RenderPage(r.Context(), RideDetailPage(RideDetailView{RideView: buildRideView(item)}), w)
+		return
+	}
 	parsed, err := ride.ParseFile(ride.GPXRideParser{}, item.GPXPath)
 	if err != nil {
 		slog.Error("Failed to load ride route", "ride_id", id, "file", item.GPXPath, "error", err)
@@ -297,6 +302,22 @@ func (s *Server) syncRides(client syncClient, gpxDir string, from, to time.Time,
 		}
 		activity, gpxData, err := client.Get(summary.ID)
 		if err != nil {
+			if errors.Is(err, strava.ErrNoTrackPoints) {
+				_ = os.Remove(filepath.Join(gpxDir, fmt.Sprintf("activity_%d.gpx", summary.ID)))
+				if saveErr := rides.Save(s.db, rideFromActivity(externalID, "", activity)); saveErr != nil {
+					if reportErr := skipSyncActivity(&progress, report, summary, fmt.Errorf("save metadata: %w", saveErr)); reportErr != nil {
+						return progress, reportErr
+					}
+					continue
+				}
+				progress.Imported++
+				progress.Completed++
+				if reportErr := reportSyncProgress(report, progress); reportErr != nil {
+					return progress, reportErr
+				}
+				slog.Info("Imported Strava activity without route", "activity", activity.ID, "name", activity.Name)
+				continue
+			}
 			if err := skipSyncActivity(&progress, report, summary, err); err != nil {
 				return progress, err
 			}
@@ -310,22 +331,7 @@ func (s *Server) syncRides(client syncClient, gpxDir string, from, to time.Time,
 			}
 			continue
 		}
-		activityType := activity.SportType
-		if activityType == "" {
-			activityType = activity.Type
-		}
-		if err := rides.Save(s.db, rides.Ride{
-			ExternalID:          externalID,
-			GPXPath:             gpxPath,
-			Name:                activity.Name,
-			Type:                activityType,
-			StartDate:           activity.StartDate,
-			DistanceM:           activity.DistanceM,
-			MovingTimeS:         activity.MovingTimeS,
-			ElapsedTimeS:        activity.ElapsedTimeS,
-			TotalElevationGainM: activity.TotalElevationGainM,
-			AverageSpeedMps:     activity.AverageSpeedMps,
-		}); err != nil {
+		if err := rides.Save(s.db, rideFromActivity(externalID, gpxPath, activity)); err != nil {
 			_ = os.Remove(gpxPath)
 			if reportErr := skipSyncActivity(&progress, report, summary, fmt.Errorf("save activity: %w", err)); reportErr != nil {
 				return progress, reportErr
@@ -342,6 +348,25 @@ func (s *Server) syncRides(client syncClient, gpxDir string, from, to time.Time,
 	return progress, nil
 }
 
+func rideFromActivity(externalID, gpxPath string, activity strava.Activity) rides.Ride {
+	activityType := activity.SportType
+	if activityType == "" {
+		activityType = activity.Type
+	}
+	return rides.Ride{
+		ExternalID:          externalID,
+		GPXPath:             gpxPath,
+		Name:                activity.Name,
+		Type:                activityType,
+		StartDate:           activity.StartDate,
+		DistanceM:           activity.DistanceM,
+		MovingTimeS:         activity.MovingTimeS,
+		ElapsedTimeS:        activity.ElapsedTimeS,
+		TotalElevationGainM: activity.TotalElevationGainM,
+		AverageSpeedMps:     activity.AverageSpeedMps,
+	}
+}
+
 func skipSyncActivity(progress *SyncProgress, report func(SyncProgress) error, activity strava.Activity, err error) error {
 	progress.Skipped++
 	progress.Completed++
diff --git a/web/server_test.go b/web/server_test.go
index 46828d1..5964c5a 100644
--- a/web/server_test.go
+++ b/web/server_test.go
@@ -150,6 +150,31 @@ func TestHandlerRendersRideDetailWithEmbeddedRoute(t *testing.T) {
 	assert.Contains(t, body, `"coordinates":[[5,43]`)
 }
 
+func TestHandlerRendersRideDetailWithoutRoute(t *testing.T) {
+	server, db := newWebTestServer(t)
+	item := rides.Ride{
+		ExternalID: "strava:14701658670",
+		Name:       "Indoor Ride",
+		Type:       "VirtualRide",
+		StartDate:  time.Date(2026, 8, 1, 7, 0, 0, 0, time.UTC),
+		DistanceM:  20_000,
+	}
+	require.NoError(t, rides.Save(db, item))
+	stored, found, err := rides.GetByExternalID(db, item.ExternalID)
+	require.NoError(t, err)
+	require.True(t, found)
+
+	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/rides/%d", stored.ID), nil)
+	response := httptest.NewRecorder()
+	server.Handler().ServeHTTP(response, req)
+
+	body := response.Body.String()
+	assert.Equal(t, http.StatusOK, response.Code)
+	assert.Contains(t, body, "Indoor Ride")
+	assert.NotContains(t, body, "The recorded route is unavailable.")
+	assert.NotContains(t, body, `id="ride-map"`)
+}
+
 func TestHandlerReturnsNotFoundForUnknownRide(t *testing.T) {
 	server, _ := newWebTestServer(t)
 	req := httptest.NewRequest(http.MethodGet, "/rides/999999", nil)
@@ -286,6 +311,41 @@ func TestSyncRidesContinuesAfterInvalidActivity(t *testing.T) {
 	assert.NoFileExists(t, filepath.Join(gpxDir, "activity_14701658670.gpx"))
 }
 
+func TestSyncRidesSavesActivityWithoutRoute(t *testing.T) {
+	server, db := newWebTestServer(t)
+	indoorID := int64(14701658670)
+	validID := int64(14701658671)
+	startDate := time.Date(2026, 8, 1, 7, 0, 0, 0, time.UTC)
+	client := fakeSyncClient{
+		activities: []strava.Activity{
+			{ID: indoorID, Name: "Indoor activity", Type: "VirtualRide", StartDate: startDate, DistanceM: 20_000},
+			{ID: validID, Name: "Valid activity", Type: "Ride", StartDate: startDate},
+		},
+		results: map[int64]fakeSyncResult{
+			indoorID: {activity: strava.Activity{ID: indoorID, Name: "Indoor activity", Type: "VirtualRide", StartDate: startDate, DistanceM: 20_000}, err: strava.ErrNoTrackPoints},
+			validID:  {activity: strava.Activity{ID: validID, Name: "Valid activity", Type: "Ride", StartDate: startDate}, data: []byte(validTrackGPX)},
+		},
+	}
+	gpxDir := t.TempDir()
+	staleGPXPath := filepath.Join(gpxDir, "activity_14701658670.gpx")
+	require.NoError(t, os.WriteFile(staleGPXPath, []byte(emptyTrackGPX), 0o600))
+
+	progress, err := server.syncRides(client, gpxDir, startDate, startDate.AddDate(0, 0, 1), nil)
+
+	require.NoError(t, err)
+	assert.Equal(t, SyncProgress{Total: 2, Completed: 2, Imported: 2}, progress)
+	indoor, found, err := rides.GetByExternalID(db, "strava:14701658670")
+	require.NoError(t, err)
+	require.True(t, found)
+	assert.Empty(t, indoor.GPXPath)
+	_, ready := indoor.CotacolScore()
+	assert.False(t, ready)
+	assert.NoFileExists(t, staleGPXPath)
+	_, found, err = rides.GetByExternalID(db, "strava:14701658671")
+	require.NoError(t, err)
+	assert.True(t, found)
+}
+
 func TestSyncRejectsConcurrentImport(t *testing.T) {
 	server, _ := newWebTestServer(t)
 	appConfig, err := config.Load(server.configPath)