sander/rowsandall
Private
Public Access
1
0
Fork 0
Code Activity

changing nk import to async

Browse Source
This commit is contained in:
Sander Roosendaal
2021-04-21 08:28:09 +02:00
parent 0cbce4df9f
commit c278f7b900
4 changed files with 426 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

350
rowers/models.py
View File

File diff suppressed because it is too large Load Diff

44
rowers/plannedsessions.py
View File

@@ -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_durationdistance(d):
sdict = ps_dict_order(d)
return sdict
def ps_dict_get_description(d,short=False):
def ps_dict_get_description(d,short=False): # pragma: no cover
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

2
rowers/templates/nk_list_import.html
View File

@@ -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>

247
rowers/tests/test_unit_tests.py
View File

@@ -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()