changing nk import to async

rowers/plannedsessions.py

@@ -50,7 +50,7 @@ def to_time(milliseconds):
 def rdata(file,rower=rrower()):
     try:
         res = rrdata(csvfile=file,rower=rower)
-    except (IOError, IndexError, EOFError,FileNotFoundError):
+    except (IOError, IndexError, EOFError,FileNotFoundError): # pragma: no cover
         try:
             res = rrdata(csvfile=file+'.gz',rower=rower)
         except (IOError, IndexError, EOFError,FileNotFoundError):
@@ -85,16 +85,7 @@ from rowers.tasks import (
     )
 from rowers.utils import totaltime_sec_to_string
 
-# nog niet af
+def ps_dict_get_description(d,short=False): # pragma: no cover
-def ps_dict_get_durationdistance(d):
-    sdict = ps_dict_order(d)
-    return sdict
-
-
-
-
-
-def ps_dict_get_description(d,short=False):
     sdict,totalmeters,totalseconds = ps_dict_order(d,short=short)
     s = ''
     for item in sdict:
@@ -115,35 +106,6 @@ def ps_dict_get_description_html(d,short=False):
     return s
 
 
-
-class FitWorkoutSteps(object):
-    def __init__(self,json_string,name='',sport='Custom'):
-        self.json = json_string
-        self.steps = json.loads(json_string)
-
-        self.name = name
-        self.sport = sport
-        # message 0 is file id
-        # message 1 must be workout description
-
-    def to_json(self):
-        d = self.get_dict()
-
-        return json.dumps(d)
-
-    def get_dict(self):
-        return self.steps
-
-
-    def get_description(self):
-        s = ''
-        for step in self.steps:
-            s += step_to_string(step)
-            s += '\n'
-
-        return s
-
-
 def checkscores(r,macrocycles):
     for m in macrocycles:
         createmesofillers(m)
@@ -246,7 +208,7 @@ def get_execution_report(rower,startdate,enddate,plan=None):
         mesos = TrainingMesoCycle.objects.filter(plan__in=macros).order_by("startdate")
         micros = TrainingMicroCycle.objects.filter(plan__in=mesos).order_by("startdate")
         micros = micros.exclude(enddate__lte=startdate).exclude(startdate__gte=enddate)
-    else:
+    else: # pragma: no cover
         plans = TrainingPlan.objects.filter(startdate__lte=startdate,enddate__gte=startdate)
         plans2 = TrainingPlan.objects.filter(enddate__lte=enddate,startdate__lte=enddate)
         plans = plans | plans2

rowers/templates/nk_list_import.html

@@ -33,7 +33,7 @@
         {% for workout in workouts %}
         <tr>
           <td>
-            <a href="/rowers/workout/nkimport/{{ workout|lookup:'id' }}/">Import</a></td>
+            <a href="/rowers/workout/nkimport/{{ workout|lookup:'id' }}/async/">Import</a></td>
           <td>{{ workout|lookuplong:'name' }}</td>
           <td class="block" style="width:auto">{{ workout|lookuplong:'starttime' }}</td>
           <td>{{ workout|lookup:'duration' }} </td>

rowers/tests/test_unit_tests.py

@@ -5,6 +5,7 @@ from __future__ import unicode_literals
 
 from .statements import *
 from rowers.mytypes import rowtypes
+from rowers.utils import allmonths,allsundays
 
 
 nu = datetime.datetime.now()
@@ -12,8 +13,11 @@ nu = datetime.datetime.now()
 # interactive plots
 from rowers import interactiveplots
 from rowers import dataprep
+from rowers import plannedsessions
 from rowers.views.workoutviews import get_video_id
 
+
+
 class OtherUnitTests(TestCase):
     def test_get_video_id(self):
         url1 = 'http://youtu.be/_lOT2p_FCvA'
@@ -49,6 +53,249 @@ class OtherUnitTests(TestCase):
 
         self.assertEqual(result,expected)
 
+class PlannedSessionTests(TestCase):
+    def setUp(self):
+        self.u = UserFactory()
+
+        self.r = Rower.objects.create(user=self.u,
+                                      birthdate=faker.profile()['birthdate'],
+                                      gdproptin=True,surveydone=True,
+                                      gdproptindate=timezone.now(),
+                                      rowerplan='coach')
+
+        self.c = Client()
+        self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
+        self.factory = RequestFactory()
+        self.password = faker.word()
+        self.u.set_password(self.password)
+        self.u.save()
+
+        self.u2 = UserFactory(username='testbasicuser')
+        self.r2 = Rower.objects.create(user=self.u2,
+                                       birthdate=faker.profile()['birthdate'],
+                                       gdproptin=True,surveydone=True,
+                                       gdproptindate=timezone.now(),
+                                       rowerplan='basic')
+
+        self.password2 = faker.word()
+        self.u2.set_password(self.password2)
+        self.u2.save()
+
+        self.team = Team.objects.create(
+            name = faker.word(),
+            notes = faker.text(),
+            manager = self.u,
+            )
+
+        self.team.save()
+
+        self.r.team.add(self.team)
+        self.r2.team.add(self.team)
+        self.r.save()
+        self.r2.save()
+
+
+        result = get_random_file(filename='rowers/tests/testdata/2019-01-13_session.csv',name='sprintervals')
+
+
+        self.factory = RequestFactory()
+        self.password = faker.word()
+        self.u.set_password(self.password)
+        self.u.save()
+
+        self.w1 = Workout.objects.create(
+            name='sprintervals',
+            notes=faker.text(),
+            startdatetime = result['startdatetime'],
+            starttime = result['starttime'],
+            workouttype='rower',
+            date=result['date'],
+            duration=result['duration'],
+            distance=result['totaldist'],
+            csvfilename=result['filename'],
+            trimp = 77,
+            rscore = 69,
+            hrtss = 43,
+            normp = 236,
+            user=self.r,
+        )
+
+        # plan
+        self.target = TrainingTarget.objects.create(
+            name = faker.word(),
+            manager = self.u.rower,
+            notes = faker.text()
+        )
+        self.target.rowers.add(self.u.rower)
+        self.target.save()
+
+        self.plan = TrainingPlan.objects.create(
+            manager = self.u.rower,
+            name = faker.word(),
+            status=True,
+            target = self.target,
+            startdate=timezone.now().date(),
+            enddate = self.target.date,
+        )
+
+        self.plan.rowers.add(self.u.rower)
+        self.plan.save()
+
+        # cycles
+        self.macro = TrainingMacroCycle.objects.create(
+            plan=self.plan,
+            name=faker.word(),
+            type='userdefined',
+            notes = faker.text(),
+            startdate = self.plan.startdate,
+            enddate = self.plan.enddate,
+        )
+
+        mesos = TrainingMesoCycle.objects.filter(plan=self.macro)
+        for m in mesos:
+            m.delete()
+
+        monthstarts = [d for d in allmonths(self.macro.startdate,self.macro.enddate)]
+        monthstarts.append(self.macro.enddate)
+
+        for i in range(len(monthstarts)-1):
+            firstday = monthstarts[i]
+            lastday = monthstarts[i+1]-datetime.timedelta(days=1)
+            if lastday < self.macro.enddate and i == len(monthstarts)-2:
+                lastday = self.macro.enddate
+
+            meso = TrainingMesoCycle(startdate=firstday,
+                                     enddate=lastday,
+                                     plan=self.macro,
+                                     name = '%s' % firstday.strftime("%B"),
+                                     type = 'userdefined')
+            meso.save()
+
+        mesos = TrainingMesoCycle.objects.filter(plan=self.macro)
+
+        for cycle in mesos:
+            micros = TrainingMicroCycle.objects.filter(plan=cycle)
+            for m in micros:
+                m.delete()
+
+            sundays = [s for s in allsundays(cycle.startdate,cycle.enddate)]
+
+            if sundays and sundays[-1] < cycle.enddate:
+                sundays = sundays+[cycle.enddate]
+            elif not sundays:
+                sundays = [cycle.enddate]
+
+            for i in range(len(sundays)):
+                if i==0:
+                    monday = cycle.startdate
+                else:
+                    monday = sundays[i]-datetime.timedelta(days=6)
+                    if monday < cycle.startdate:
+                        monday = cycle.startdate
+
+                nextsunday = sundays[i]
+
+                micro = TrainingMicroCycle(startdate=monday,
+                                           enddate=nextsunday,
+                                           plan=cycle,
+                                           name = 'Week %s' % monday.isocalendar()[1],
+                                           type='userdefined')
+                micro.save()
+
+
+        # sessions
+        startdatetime = self.w1.startdatetime
+
+        startdate = (startdatetime-datetime.timedelta(days=1)).date()
+        enddate = (startdatetime+datetime.timedelta(days=1)).date()
+        preferreddate = startdatetime.date()
+
+        self.startdate = startdate
+        self.enddate = enddate
+
+        self.ps_rscore = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='test',
+            sessionmode = 'rScore',
+            criterium = 'none',
+            sessionvalue = 69,
+            sessionunit='None',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+
+
+        self.ps_rscore.save()
+        added = plannedsessions.add_rower_session(self.u.rower,self.ps_rscore)
+
+        self.ps_dist = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='test',
+            sessionmode = 'distance',
+            criterium = 'none',
+            sessionvalue = result['totaldist'],
+            sessionunit='m',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+
+
+        self.ps_dist.save()
+        added = plannedsessions.add_rower_session(self.u.rower,self.ps_dist)
+
+        self.ps_time = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='test',
+            sessionmode = 'time',
+            criterium = 'none',
+            sessionvalue = 38,
+            sessionunit='min',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+
+
+        self.ps_time.save()
+        added = plannedsessions.add_rower_session(self.u.rower,self.ps_time)
+
+        self.ps_trimp = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='test',
+            sessionmode = 'TRIMP',
+            criterium = 'none',
+            sessionvalue = 77,
+            sessionunit='none',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+
+
+        self.ps_trimp.save()
+        added = plannedsessions.add_rower_session(self.u.rower,self.ps_trimp)
+        added = plannedsessions.add_team_session(self.team,self.ps_trimp)
+        self.ps_trimp.save()
+
+
+    def tearDown(self):
+        pass
+
+    def test_to_time(self):
+        calculatedTime = plannedsessions.to_time(8100000)
+        expectedTime = datetime.time(2,15,0,0)
+
+    def test_checkscores(self):
+        macrocycles = TrainingMacroCycle.objects.filter(plan=self.plan)
+        plannedsessions.checkscores(self.r,macrocycles)
+
+    def test_executionreport(self):
+        data, ok = plannedsessions.get_execution_report(self.r,self.plan.startdate,self.plan.enddate)
+        self.assertEqual(ok,'ok')
+
+    def test_todays_micro(self):
+        micro1 = plannedsessions.get_todays_micro(self.plan)
+        micro2 = plannedsessions.get_todays_micro(self.plan,thedate=datetime.date.today())
+        self.assertEqual(micro1.id,micro2.id)
+
 class DataPrepTests(TestCase):
     def setUp(self):
         self.u = UserFactory()