Adds garmin gear upsert

Author: ckdake

TODO.md

@@ -5,6 +5,7 @@ Tracked here for visibility. PRs and issues welcome.
 ## Overall capabilitites
 
 next:
+- [ ] bug: worker logs are only on stdout, not in sentry logs
 - [ ] feat: "add" to spreadsheet data
 - [ ] feat: on sync, use Activty table to link up to all provider activities
 - [ ] bug: pulling provider in ui for a month doesn't get new activites in the month

app/static/settings.js

@@ -32,7 +32,8 @@ const PROVIDER_META = {
         ],
     },
     garmin:      { label: 'Garmin',       sync_equipment: true,  sync_name: true,
-        instructions: 'Garmin authentication tokens are valid for approximately one year. Re-authenticate before they expire to avoid interruption.',
+        instructions: 'Garmin authentication tokens are valid for approximately one year. Re-authenticate before they expire to avoid interruption. ' +
+            'When syncing equipment, if a gear name does not already exist in your Garmin account it will be created automatically using the name as both the display name and make/model.',
         text_fields: [] },
     spreadsheet: {
         label: 'Spreadsheet', sync_equipment: true, sync_name: true,

tests/providers/test_garmin.py

@@ -417,19 +417,59 @@ def test_set_gear_removes_existing_gear(self):
         mock_client.remove_gear_from_activity.assert_called_once_with("uuid-old", "99999")
         mock_client.add_gear_to_activity.assert_called_once_with("uuid-new", "99999")
 
-    def test_set_gear_gear_not_found(self):
-        """Test set_gear returns False when gear name is not in account."""
+    def test_create_gear_success(self):
+        """Test _create_gear POSTs to Garmin API and returns the UUID."""
         provider = GarminProvider()
 
         mock_client = Mock()
         mock_client.get_device_last_used.return_value = {"userProfileNumber": "12345"}
-        mock_client.get_gear.return_value = [{"uuid": "uuid-bike", "displayName": "Trek Bike"}]
+        mock_client.garth.post.return_value.json.return_value = {"uuid": "new-uuid-123", "displayName": "New Bike"}
         provider._get_client = Mock(return_value=mock_client)
 
-        result = provider.set_gear("Unknown Gear", "99999")
+        uuid = provider._create_gear("New Bike")
+
+        assert uuid == "new-uuid-123"
+        mock_client.garth.post.assert_called_once_with(
+            "connectapi",
+            "/gear-service/gear",
+            json={
+                "displayName": "New Bike",
+                "customMakeModel": "New Bike",
+                "gearStatusName": "active",
+                "userProfilePk": "12345",
+            },
+        )
 
-        assert result is False
-        mock_client.add_gear_to_activity.assert_not_called()
+    def test_create_gear_no_uuid_raises(self):
+        """Test _create_gear raises if the API response contains no UUID."""
+        provider = GarminProvider()
+
+        mock_client = Mock()
+        mock_client.get_device_last_used.return_value = {"userProfileNumber": "12345"}
+        mock_client.garth.post.return_value.json.return_value = {}
+        provider._get_client = Mock(return_value=mock_client)
+
+        with pytest.raises(RuntimeError, match="no UUID"):
+            provider._create_gear("New Bike")
+
+    def test_set_gear_creates_when_not_found(self):
+        """Test set_gear creates the gear in Garmin Connect if it doesn't exist yet."""
+        provider = GarminProvider()
+
+        mock_client = Mock()
+        mock_client.get_device_last_used.return_value = {"userProfileNumber": "12345"}
+        mock_client.get_gear.return_value = []  # no existing gear
+        mock_client.garth.post.return_value.json.return_value = {"uuid": "new-uuid-abc"}
+        mock_client.get_activity_gear.return_value = []
+        provider._get_client = Mock(return_value=mock_client)
+
+        with patch("tracekit.providers.garmin.garmin_provider.GarminActivity") as mock_act_cls:
+            mock_act_cls.get_or_none.return_value = None
+            result = provider.set_gear("Brand New Bike", "99999")
+
+        assert result is True
+        mock_client.garth.post.assert_called_once()
+        mock_client.add_gear_to_activity.assert_called_once_with("new-uuid-abc", "99999")
 
     def test_set_gear_api_error(self):
         """Test set_gear returns False on API error."""

tracekit/providers/garmin/garmin_provider.py

@@ -399,23 +399,43 @@ def _find_gear_uuid(self, gear_name: str) -> str | None:
                 return gear_item.get("uuid")
         return None
 
+    def _create_gear(self, gear_name: str) -> str:
+        """Create a new gear item in Garmin Connect and return its UUID.
+
+        Uses the gear name as both displayName and customMakeModel — Garmin
+        requires these fields but doesn't enforce their values.
+        """
+        client = self._get_client()
+        device_last_used = client.get_device_last_used()
+        user_profile_pk = device_last_used["userProfileNumber"]
+        payload = {
+            "displayName": gear_name,
+            "customMakeModel": gear_name,
+            "gearStatusName": "active",
+            "userProfilePk": user_profile_pk,
+        }
+        result = client.garth.post("connectapi", "/gear-service/gear", json=payload).json()
+        uuid = result.get("uuid")
+        if not uuid:
+            raise RuntimeError(f"Garmin gear creation returned no UUID: {result!r}")
+        print(f"Created Garmin gear '{gear_name}' with UUID {uuid}")
+        return uuid
+
     def set_gear(self, gear_name: str, activity_id: str) -> bool:
         """Set gear for an activity on Garmin Connect.
 
-        Looks up the gear UUID by display name, removes any existing gear from
-        the activity, then adds the new gear.  Also upserts the local
-        GarminActivity.equipment field so the DB stays in sync.
-
-        Returns True on success, False if the gear name is not found in the
-        user's Garmin account.
+        Looks up the gear UUID by display name; if not found, creates the gear
+        first.  Removes any existing gear from the activity, then adds the new
+        gear.  Also upserts the local GarminActivity.equipment field so the DB
+        stays in sync.
         """
         try:
             client = self._get_client()
 
             gear_uuid = self._find_gear_uuid(gear_name)
             if not gear_uuid:
-                print(f"Gear '{gear_name}' not found in Garmin Connect account")
-                return False
+                print(f"Gear '{gear_name}' not found — creating it in Garmin Connect")
+                gear_uuid = self._create_gear(gear_name)
 
             # Remove any gear currently associated with this activity
             try: