import somewhat working (workout type not)

rowers/integrations/intervals.py

@@ -6,6 +6,7 @@ from rowers import mytypes
 
 from rowers.rower_rules import is_workout_user, ispromember
 from rowers.utils import myqueue, dologging, custom_exception_handler
+from rowers.tasks import handle_intervals_getworkout
 
 import urllib
 import gzip
@@ -26,13 +27,25 @@ queue = django_rq.get_queue('default', default_timeout=3600)
 queuelow = django_rq.get_queue('low', default_timeout=3600)
 queuehigh = django_rq.get_queue('high', default_timeout=3600)
 
+
+def seconds_to_duration(seconds):
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+    remaining_seconds = seconds % 60
+
+    # Format as "H:MM:SS" or "MM:SS" if no hours
+    if hours > 0:
+        return f"{int(hours)}:{int(minutes):02}:{int(remaining_seconds):02}"
+    else:
+        return f"{int(minutes)}:{int(remaining_seconds):02}"
+
 headers = {
     'Content-Type': 'application/json',
     'Accept': 'application/json'
 }
 
 intervals_authorize_url = 'https://intervals.icu/oauth/authorize?'
-intervals_token_url = 'https://intervals.icu/oauth/token'
+intervals_token_url = 'https://intervals.icu/api/oauth/token'
 
 class IntervalsIntegration(SyncIntegration):
     def __init__(self, *args, **kwargs):
@@ -47,14 +60,33 @@ class IntervalsIntegration(SyncIntegration):
             'expirydatename': 'intervals_exp',
             'refreshtokenname': 'intervals_r',
             'bearer_auth': True,
-            'base_uri': 'https://intervals.icu/api/v1/',
+            'base_url': 'https://intervals.icu/api/v1/',
             'grant_type': 'refresh_token',
             'headers': headers,
-            'scope': 'ACTIVITY:WRITE'
+            'scope': 'ACTIVITY:WRITE, LIBRARY:READ',
         }
 
     def get_token(self, code, *args, **kwargs):
-        return super(IntervalsIntegration, self).get_token(code, *args, **kwargs)
+        post_data = {
+            'client_id': str(self.oauth_data['client_id']),
+            'client_secret': self.oauth_data['client_secret'],
+            'code': code,
+        }
+
+        response = requests.post(
+            intervals_token_url,
+            data=post_data,
+        )
+
+        if response.status_code not in [200, 201]:
+            dologging('intervals.icu.log',response.text)
+            return [0,"Failed to get token. ",0]
+        
+        token_json = response.json()
+        access_token = token_json['access_token']
+        athlete = token_json['athlete']
+
+        return [access_token, athlete, '']
 
     def get_name(self):
         return 'Intervals'
@@ -63,8 +95,8 @@ class IntervalsIntegration(SyncIntegration):
         return 'intervals'
 
     def open(self, *args, **kwargs):
-        dologging('intervals.icu.log', "Getting token for user {id}".format(id=self.rower.id))
-        token = super(IntervalsIntegration).open(*args, **kwargs)
+        # dologging('intervals.icu.log', "Getting token for user {id}".format(id=self.rower.id))
+        token = super(IntervalsIntegration, self).open(*args, **kwargs)
         return token
 
     def createworkoutdata(self, w, *args, **kwargs) -> str:
@@ -73,13 +105,63 @@ class IntervalsIntegration(SyncIntegration):
     def workout_export(self, workout, *args, **kwargs) -> str:
         return NotImplemented
 
-    def get_workouts(workout, *args, **kwargs) -> int:
-        return NotImplemented
+    def get_workout_list(self, *args, **kwargs) -> int:
+        url = self.oauth_data['base_url'] + 'athlete/0/activities?'
+        startdate = timezone.now() - timedelta(days=365)
+        enddate = timezone.now() + timedelta(days=1)
+        url += 'oldest=' + startdate.strftime('%Y-%m-%d') + '&newest=' + enddate.strftime('%Y-%m-%d')
+        headers = {
+            'accept': '*/*',
+            'authorization': 'Bearer ' + self.open(),
+        }
+
+        response = requests.get(url, headers=headers)
+        if response.status_code != 200:
+            dologging('intervals.icu.log', response.text)
+            return []
+
+        data = response.json()
+        known_interval_ids = get_known_ids(self.rower, 'intervalsid')
+
+        workouts = []
+        
+        for item in data:
+            i = item['id']
+            r = item['type']
+            d = item['distance']
+            ttot = seconds_to_duration(item['moving_time'])
+            s = item['start_date']
+            s2 = ''
+            c = item['name']
+            if i in known_interval_ids:
+                nnn = ''
+            else:
+                nnn = 'NEW'
+
+            keys = ['id','distance','duration','starttime',
+                    'rowtype','source','name','new']
+
+            values = [i, d, ttot, s, r, s2, c, nnn]
+
+            ress = dict(zip(keys, values))
+            workouts.append(ress)
+        
+        return workouts
+        
 
     def get_workout(self, id, *args, **kwargs) -> int:
-        return NotImplemented
+        _ = self.open()
+        r = self.rower
 
-    def get_workout_list(self, *args, **kwargs) -> list:
+        record = create_or_update_syncrecord(r, None, intervalsid=id)
+
+        _ = myqueue(queuehigh,
+                    handle_intervals_getworkout,
+                    self.rower,
+                    self.rower.intervals_token,
+                    id)
+
+    def get_workouts(workout, *args, **kwargs) -> list:
         return NotImplemented
 
     def make_authorization_url(self, *args, **kwargs):