Add more info to trackables (#19)

* Add more info to trackables

Author: Sholofly

geocachingapi/geocachingapi.py

@@ -24,7 +24,8 @@
     GeocachingStatus,
     GeocachingSettings,
     GeocachingApiEnvironment,
-    GeocachingApiEnvironmentSettings
+    GeocachingApiEnvironmentSettings,
+    GeocachingTrackableJourney
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -168,13 +169,24 @@ async def _update_trackables(self, data: Dict[str, Any] = None) -> None:
                 "holder",
                 "trackingNumber",
                 "kilometersTraveled",
+                "milesTraveled",
                 "currentGeocacheCode",
-                "currentGeocacheName"
+                "currentGeocacheName",
+                "isMissing"
             ])
             data = await self._request("GET", f"/trackables?fields={fields}&type=3")
         self._status.update_trackables_from_dict(data)
+        if len(self._status.trackables) > 0:
+            for trackable in self._status.trackables.values():
+                latest_journey_data = await self._request("GET",f"/trackables/{trackable.reference_code}/journeys?sort=loggedDate-&take=1")
+                if len(latest_journey_data) == 1:
+                    trackable.latest_journey = GeocachingTrackableJourney(data=latest_journey_data[0])
+                else:
+                    trackable.latest_journey = None
+
         _LOGGER.debug(f'Trackables updated.')
 
+    
     async def close(self) -> None:
         """Close open client session."""
         if self._session and self._close_session:

geocachingapi/models.py

@@ -48,19 +48,47 @@ def update_from_dict(self, data: Dict[str, Any]) -> None:
         self.souvenir_count = try_get_from_dict(data, "souvenirCount", self.souvenir_count)
         self.awarded_favorite_points = try_get_from_dict(data, "awardedFavoritePoints", self.awarded_favorite_points)
 
+@dataclass
+class GeocachingCoordinate:
+    """Class to hold a Geocaching coordinate"""
+    latitude: Optional[str] = None
+    longitude: Optional[str] = None
+
+    def __init__(self, *, data: Dict[str, Any]) -> GeocachingCoordinate:
+        """Constructor for Geocaching coordinates"""
+        self.latitude = try_get_from_dict(data, "latitude", None)
+        self.longitude = try_get_from_dict(data, "longitude", None)
+
+@dataclass
+class GeocachingTrackableJourney:
+    """Class to hold Geocaching trackable journey information"""
+    coordinates: GeocachingCoordinate = None
+    logged_date: Optional[datetime] = None
+
+    def __init__(self, *, data: Dict[str, Any]) -> GeocachingTrackableJourney:
+        """Constructor for Geocaching trackable journey"""
+        if "coordinates" in data:
+            self.coordinates = GeocachingCoordinate(data=data["coordinates"])
+        else:
+            self.coordinates = None
+        self.logged_date = try_get_from_dict(data, "loggedDate", self.logged_date)
+
 @dataclass
 class GeocachingTrackable:
     """Class to hold the Geocaching trackable information"""
     reference_code: Optional[str] = None
     name: Optional[str] = None
     holder: GeocachingUser = None
     tracking_number: Optional[str] = None
-    kilometers_traveled: Optional[datetime] = None
+    kilometers_traveled: Optional[str] = None
+    miles_traveled: Optional[str] = None
     current_geocache_code: Optional[str] = None
     current_geocache_name: Optional[str] = None
-
+    latest_journey: GeocachingTrackableJourney = None
+    is_missing: bool = False
+    
     def update_from_dict(self, data: Dict[str, Any]) -> None:
-        """Update trackble from the API"""
+        """Update trackable from the API"""
         self.reference_code = try_get_from_dict(data, "referenceCode", self.reference_code)
         self.name = try_get_from_dict(data, "name", self.name)
         if data["holder"] is not None:
@@ -72,8 +100,10 @@ def update_from_dict(self, data: Dict[str, Any]) -> None:
 
         self.tracking_number = try_get_from_dict(data, "trackingNumber", self.tracking_number)
         self.kilometers_traveled = try_get_from_dict(data, "kilometersTraveled", self.kilometers_traveled)
+        self.miles_traveled = try_get_from_dict(data, "milesTraveled", self.miles_traveled)
         self.current_geocache_code = try_get_from_dict(data, "currectGeocacheCode", self.current_geocache_code)
         self.current_geocache_name = try_get_from_dict(data, "currentGeocacheName", self.current_geocache_name)
+        self.is_missing = try_get_from_dict(data, "isMissing", self.is_missing)
 
 class GeocachingStatus:
     """Class to hold all account status information"""

tests/test.py

@@ -2,17 +2,28 @@
 import asyncio
 import logging
 from geocachingapi import GeocachingApi, GeocachingStatus
-from geocachingapi.models import GeocachingApiEnvironment, GeocachingSettings
+from geocachingapi.models import GeocachingApiEnvironment, GeocachingSettings, GeocachingTrackable
 from my_token import TOKEN
-logging.basicConfig(level=logging.DEBUG)
+logging.basicConfig(level=logging.INFO)
 mylogger = logging.getLogger()
 
 async def test():
-    """Function to test GeocachingAPI  integration"""
+    """Function to test GeocachingAPI integration"""
     status:GeocachingStatus = None
     api = GeocachingApi(token=TOKEN, environment=GeocachingApiEnvironment.Staging, settings = GeocachingSettings(fetch_trackables=True))
     status = await api.update()
     print(status.user.reference_code)
+    for trackable in status.trackables.values():
+        print('----------------------')
+        print(f'Trackable code: {trackable.reference_code}')
+        print(f'Trackable name: {trackable.name}')
+        print(f'Kilometers traveled: {trackable.kilometers_traveled}km')
+        print(f'Miles traveled: {trackable.miles_traveled}mi')
+        print(f'Missing?: {trackable.is_missing}')
+        if trackable.latest_journey:
+            print(f'last log: {trackable.latest_journey.logged_date}')
+            print(f'latitude: {trackable.latest_journey.coordinates.latitude}')
+            print(f'longitude: {trackable.latest_journey.coordinates.longitude}')
     await api.close()
 loop = asyncio.get_event_loop()
 loop.run_until_complete(test())