✨ Provide tracked trackables with setting (#20)

* ✨ Provide tracked trackables with setting

* Allow updating settings

* ✨ Add last log information

Author: Sholofly

geocachingapi/geocachingapi.py

@@ -138,7 +138,7 @@ async def _request(self, method, uri, **kwargs) -> ClientResponse:
 
     async def update(self) -> GeocachingStatus:
         await self._update_user(None)
-        if self._settings.fetch_trackables:
+        if len(self._settings.trackable_codes) > 0:
             await self._update_trackables()
         _LOGGER.info(f'Status updated.')
         return self._status
@@ -172,9 +172,11 @@ async def _update_trackables(self, data: Dict[str, Any] = None) -> None:
                 "milesTraveled",
                 "currentGeocacheCode",
                 "currentGeocacheName",
-                "isMissing"
+                "isMissing",
+                "type"
             ])
-            data = await self._request("GET", f"/trackables?fields={fields}&type=3")
+            trackable_parameters = ",".join(self._settings.trackable_codes)
+            data = await self._request("GET", f"/trackables?referenceCodes={trackable_parameters}&fields={fields}&expand=trackablelogs:1")
         self._status.update_trackables_from_dict(data)
         if len(self._status.trackables) > 0:
             for trackable in self._status.trackables.values():
@@ -186,7 +188,10 @@ async def _update_trackables(self, data: Dict[str, Any] = None) -> None:
 
         _LOGGER.debug(f'Trackables updated.')
 
-    
+    async def update_settings(self, settings: GeocachingSettings):
+        """Update the Geocaching settings"""
+        self._settings = settings
+        
     async def close(self) -> None:
         """Close open client session."""
         if self._session and self._close_session:

geocachingapi/models.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from array import array
 from enum import Enum
 from typing import Any, Dict, Optional, TypedDict
 
@@ -20,12 +21,15 @@ class GeocachingApiEnvironment(Enum):
 
 class GeocachingSettings:
     """Class to hold the Geocaching Api settings"""
-    fetch_trackables: bool
+    trackable_codes: array(str)
     environment: GeocachingApiEnvironment
 
-    def __init__(self, fetch_trackables:bool = False, environment:GeocachingApiEnvironment = GeocachingApiEnvironment.Production ) -> None:
+    def __init__(self, environment:GeocachingApiEnvironment = GeocachingApiEnvironment.Production, trackables:array(str) = [] ) -> None:
         """Initialize settings"""
-        self.fetch_trackables = fetch_trackables
+        self.trackable_codes = trackables
+    
+    def set_trackables(self, trackables:array(str)):
+        self.trackable_codes = trackables
 
 @dataclass
 class GeocachingUser:
@@ -37,6 +41,7 @@ class GeocachingUser:
     favorite_points: Optional[int] = None
     souvenir_count: Optional[int] = None
     awarded_favorite_points: Optional[int] = None
+    membership_level_id: Optional[int] = None
 
     def update_from_dict(self, data: Dict[str, Any]) -> None:
         """Update user from the API result"""
@@ -47,6 +52,7 @@ def update_from_dict(self, data: Dict[str, Any]) -> None:
         self.favorite_points = try_get_from_dict(data, "favoritePoints", self.favorite_points)
         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)
+        self.membership_level_id = try_get_from_dict(data, "membershipLevelId", self.membership_level_id)
 
 @dataclass
 class GeocachingCoordinate:
@@ -73,6 +79,27 @@ def __init__(self, *, data: Dict[str, Any]) -> GeocachingTrackableJourney:
             self.coordinates = None
         self.logged_date = try_get_from_dict(data, "loggedDate", self.logged_date)
 
+@dataclass
+class GeocachingTrackableLog:
+    reference_code: Optional[str] = None
+    owner: GeocachingUser = None
+    text: Optional[str] = None
+    log_type: Optional[str] = None
+    logged_date: Optional[datetime] = None
+
+    def __init__(self, *, data: Dict[str, Any]) -> GeocachingTrackableLog:
+        self.reference_code = try_get_from_dict(data, 'referenceCode',self.reference_code)
+        if self.owner is None:
+            self.owner = GeocachingUser()
+        if 'owner' in data:
+            self.owner.update_from_dict(data['owner'])
+        else:
+            self.owner = None
+        self.log_type = try_get_from_dict(data['trackableLogType'], 'name',self.log_type)
+        self.logged_date = try_get_from_dict(data, 'loggedDate',self.logged_date)
+        self.text = try_get_from_dict(data, 'text',self.text)
+
+
 @dataclass
 class GeocachingTrackable:
     """Class to hold the Geocaching trackable information"""
@@ -85,7 +112,10 @@ class GeocachingTrackable:
     current_geocache_code: Optional[str] = None
     current_geocache_name: Optional[str] = None
     latest_journey: GeocachingTrackableJourney = None
-    is_missing: bool = False
+    is_missing: bool = False,
+    trackable_type: str = None,
+    latest_log: GeocachingTrackableLog = None
+
 
     def update_from_dict(self, data: Dict[str, Any]) -> None:
         """Update trackable from the API"""
@@ -104,6 +134,10 @@ def update_from_dict(self, data: Dict[str, Any]) -> None:
         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)
+        self.trackable_type = try_get_from_dict(data, "type", self.trackable_type)
+        if "trackableLogs" in data and len(data["trackableLogs"]) > 0:
+            self.latest_log = GeocachingTrackableLog(data=data["trackableLogs"][0])
+            
 
 class GeocachingStatus:
     """Class to hold all account status information"""

tests/test.py

@@ -1,30 +1,45 @@
 """Test for Geocaching Api integration."""
 import asyncio
 import logging
-from geocachingapi import GeocachingApi, GeocachingStatus
-from geocachingapi.models import GeocachingApiEnvironment, GeocachingSettings, GeocachingTrackable
+from geocachingapi import GeocachingApi
+from geocachingapi.models import GeocachingApiEnvironment, GeocachingSettings
 from my_token import TOKEN
 logging.basicConfig(level=logging.INFO)
 mylogger = logging.getLogger()
 
 async def test():
     """Function to test GeocachingAPI integration"""
-    status:GeocachingStatus = None
-    api = GeocachingApi(token=TOKEN, environment=GeocachingApiEnvironment.Staging, settings = GeocachingSettings(fetch_trackables=True))
+    gc_settings = GeocachingSettings()
+    api = GeocachingApi(token=TOKEN, environment=GeocachingApiEnvironment.Staging, settings=gc_settings)
+    gc_settings.set_trackables(['TB87DTF'])
+    await api.update_settings(gc_settings)
+    await _update(api)
+    await api.close()
+
+
+async def _update(api:GeocachingApi):
+    """Update and print"""
     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'Trackable type: {trackable.trackable_type}')
         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'last journey: {trackable.latest_journey.logged_date}')
             print(f'latitude: {trackable.latest_journey.coordinates.latitude}')
             print(f'longitude: {trackable.latest_journey.coordinates.longitude}')
-    await api.close()
+        if trackable.latest_log:
+            print(f'last log date: {trackable.latest_log.logged_date}')
+            print(f'last log type: {trackable.latest_log.log_type}')
+            print(f'last log username: {trackable.latest_log.owner.username}')
+            print(f'last log text: {trackable.latest_log.text}')
+        
+
 loop = asyncio.get_event_loop()
 loop.run_until_complete(test())
 loop.close()