delete and add activities

rowers/integrations/intervals.py

@@ -1,5 +1,5 @@
 from .integrations import SyncIntegration, NoTokenError, create_or_update_syncrecord, get_known_ids
-from rowers.models import Rower, User, Workout, TombStone
+from rowers.models import Rower, User, Workout, TombStone, PlannedSession
 from rowingdata import rowingdata
 
 from rowers import mytypes
@@ -467,3 +467,112 @@ class IntervalsIntegration(SyncIntegration):
         ps.save()
 
         return 1
+
+    def update_calendar(self, r, event, *args, **kwargs):
+        try:
+            records = event["events"]
+        except KeyError:
+            records = []
+
+        for record in records:
+            id = record['id']
+            data = {}
+            try:
+                pss = PlannedSession.objects.filter(intervals_icu_id=id)
+                if pss.count() > 0:
+                    ps = pss[0]
+                    data = self.update_plannedsession(ps, record)
+                else:
+                    data = self.get_plannedsession(id)
+                    ps = PlannedSession(
+                        manager=r.user,
+                        intervals_icu_id=id,
+                    )
+                    ps.save()
+                    ps.rower.add(r)
+            except PlannedSession.DoesNotExist:
+                continue
+
+            # got data
+            if data:
+                ps.name = data['name']
+                ps.comment = data['description']
+                ps.startdate = arrow.get(data['start_date_local']).datetime
+                ps.enddate = arrow.get(data['end_date_local']).datetime
+                ps.preferreddate = arrow.get(data['start_date_local']).datetime
+                ps.sessionsport = mytypes.intervalsmappinginv[data['type']]
+                ps.sessiontype = 'session'
+                ps.save()
+                try:
+                    timetarget = data['time_target']
+                except KeyError:
+                    timetarget = None
+                if timetarget is None:
+                    try:
+                        timetarget = data['moving_time']
+                    except KeyError:
+                        timetarget = None
+                    if timetarget is None:
+                        timetarget = 3600
+                timetarget = int(timetarget)/60.
+                ps.sessionvalue = timetarget
+                ps.save()
+                if data['category'].lower() == 'workout':
+                    ps.fitfile = data['fitfile']
+                    ps.save()
+                    ps.update_steps()
+                if data['category'].lower() == 'target':
+                    ps.sessiontype = 'cycletarget'
+                    ps.sessionvalue = int(data['time_target'])/60.
+                    ps.enddate = ps.startdate + datetime.timedelta(days=6)
+                    ps.save()
+
+        try:
+            deleted_records = event["deleted_events"]
+        except KeyError:
+            deleted_records = []
+
+        for record in deleted_records:
+            id = record['id']
+            try:
+                pss = PlannedSession.objects.filter(intervals_icu_id=id)
+                if r.intervals_delete_plannedsession and pss.count() > 0:
+                    for ps in pss:
+                        ps.delete()
+            except PlannedSession.DoesNotExist:
+                continue
+
+        return 1
+
+    def import_activities(self, event, *args, **kwargs):
+        try:
+            record = event["activity"]
+        except KeyError:
+            records = []
+
+        try:
+            id = record['id']
+            result = self.get_workout(id)
+        except KeyError:
+            pass
+
+        return 1
+
+    def delete_activities(self, event, *args, **kwargs):
+        try:
+            record = event["activity"]
+        except KeyError:
+            records = []
+
+        try:
+            id = record['id']
+            try:
+                w = Workout.objects.get(uploadedtointervals=id)
+                if w.user == self.rower:
+                    w.delete()
+            except Workout.DoesNotExist:
+                pass
+        except KeyError:
+            pass
+
+        return 1

rowers/views/importviews.py

@@ -940,9 +940,13 @@ def intervals_webhook_view(request):
             # return invalid request if no events
             return HttpResponse(status=200)
 
+        webhook_type = None
+
+
         for event in events:
             try:
                 athlete_id = event['athlete_id']
+                webhook_type = event['type']
                 r = Rower.objects.get(intervals_owner_id=athlete_id)
             except Rower.DoesNotExist:
                 return HttpResponse(status=200)
@@ -954,78 +958,14 @@ def intervals_webhook_view(request):
 
             integration = IntervalsIntegration(r.user)
 
-            try:
+            if webhook_type.lower() == 'calendar_updated':
-                records = event["events"]
+                integration.update_calendar(r, event)
-            except KeyError:
-                records = []
 
-            for record in records:
+            if webhook_type.lower() == 'activity_uploaded':
-                id = record['id']
+                integration.import_activities(event)
-                data = {}
-                try:
-                    pss = PlannedSession.objects.filter(intervals_icu_id=id)
-                    if pss.count() > 0:
-                        ps = pss[0]
-                        data = integration.update_plannedsession(ps, record)
-                    else:
-                        data = integration.get_plannedsession(id)
-                        ps = PlannedSession(
-                            manager=r.user,
-                            intervals_icu_id=id,
-                        )
-                        ps.save()
-                        ps.rower.add(r)
-                except PlannedSession.DoesNotExist:
-                    continue
 
-                # got data
+            if webhook_type.lower() == 'activity_deleted':
-                if data:
+                integration.delete_activities(event)
-                    ps.name = data['name']
-                    ps.comment = data['description']
-                    ps.startdate = arrow.get(data['start_date_local']).datetime
-                    ps.enddate = arrow.get(data['end_date_local']).datetime
-                    ps.preferreddate = arrow.get(data['start_date_local']).datetime
-                    ps.sessionsport = mytypes.intervalsmappinginv[data['type']]
-                    ps.sessiontype = 'session'
-                    ps.save()
-                    try:
-                        timetarget = data['time_target']
-                    except KeyError:
-                        timetarget = None
-                    if timetarget is None:
-                        try:
-                            timetarget = data['moving_time']
-                        except KeyError:
-                            timetarget = None
-                        if timetarget is None:
-                            timetarget = 3600
-                    timetarget = int(timetarget)/60.
-                    ps.sessionvalue = timetarget
-                    ps.save()
-                    if data['category'].lower() == 'workout':
-                        ps.fitfile = data['fitfile']
-                        ps.save()
-                        ps.update_steps()
-                    if data['category'].lower() == 'target':
-                        ps.sessiontype = 'cycletarget'
-                        ps.sessionvalue = int(data['time_target'])/60.
-                        ps.enddate = ps.startdate + datetime.timedelta(days=6)
-                        ps.save()
-
-            try:
-                deleted_records = event["deleted_events"]
-            except KeyError:
-                deleted_records = []
-
-            for record in deleted_records:
-                id = record['id']
-                try:
-                    pss = PlannedSession.objects.filter(intervals_icu_id=id)
-                    if r.intervals_delete_plannedsession and pss.count() > 0:
-                        for ps in pss:
-                            ps.delete()
-                except PlannedSession.DoesNotExist:
-                    continue
 
     return HttpResponse(status=200)