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

fixifix

Browse Source
This commit is contained in:
Sander Roosendaal
2021-02-13 17:25:29 +01:00
parent c93c3a51e5
commit 5c5000a7b4
3 changed files with 339 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
rowers/models.py
View File

@@ -2301,6 +2301,15 @@ class PlannedSession(models.Model):
return stri return stri
def update_json(self):
# read file
if self.fitfile:
steps = steps_read_fit(settings.MEDIA_ROOT+'/'+self.fitfile.name)
self.steps_json = json.dumps(steps)
self.save()
def save(self, *args, **kwargs): def save(self, *args, **kwargs):
if self.sessionvalue <= 0: if self.sessionvalue <= 0:
self.sessionvalue = 1 self.sessionvalue = 1
@@ -2359,8 +2368,7 @@ class PlannedSession(models.Model):
if self.preferreddate < self.startdate: if self.preferreddate < self.startdate:
self.preferreddate = self.startdate self.preferreddate = self.startdate
print(self.fitfile) #super(PlannedSession,self).save(*args, **kwargs)
super(PlannedSession,self).save(*args, **kwargs)
# read file # read file
if self.fitfile: if self.fitfile:
@@ -2370,11 +2378,8 @@ class PlannedSession(models.Model):
steps = steps_read_fit(settings.MEDIA_ROOT+'/'+self.fitfile.name) steps = steps_read_fit(settings.MEDIA_ROOT+'/'+self.fitfile.name)
self.steps_json = json.dumps(steps) self.steps_json = json.dumps(steps)
try:
super(PlannedSession,self).save(*args, **kwargs)
except:
pass
super(PlannedSession,self).save(*args, **kwargs)
from django.core.validators import RegexValidator,validate_email from django.core.validators import RegexValidator,validate_email

629
rowers/tests/test_plans.py
View File

@@ -10,6 +10,7 @@ nu = datetime.datetime.now()
from rowers.utils import allmonths,allsundays from rowers.utils import allmonths,allsundays
import rowers.plannedsessions as plannedsessions import rowers.plannedsessions as plannedsessions
from django.db import transaction
@override_settings(TESTING=True) @override_settings(TESTING=True)
class TrainingPlanTest(TestCase): class TrainingPlanTest(TestCase):
@@ -37,134 +38,136 @@ class TrainingPlanTest(TestCase):
pass pass
def test_createplan(self): def test_createplan(self):
login = self.c.login(username=self.u.username, password=self.password) with transaction.atomic():
self.assertTrue(login) login = self.c.login(username=self.u.username, password=self.password)
self.assertTrue(login)
url = '/rowers/createplan/' url = '/rowers/createplan/'
response = self.c.get(url) response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
# add target # add target
targetdate = (nu+datetime.timedelta(days=300)) targetdate = (nu+datetime.timedelta(days=300))
form_data = { form_data = {
'name': faker.word(), 'name': faker.word(),
'date': targetdate.strftime("%Y-%m-%d"), 'date': targetdate.strftime("%Y-%m-%d"),
'notes': faker.text(), 'notes': faker.text(),
} }
targetform = TrainingTargetForm(form_data,user=self.u) targetform = TrainingTargetForm(form_data,user=self.u)
self.assertTrue(targetform.is_valid()) self.assertTrue(targetform.is_valid())
response = self.c.post(url,form_data) response = self.c.post(url,form_data)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
form_data = { form_data = {
'name': faker.word(), 'name': faker.word(),
'target': '1', 'target': '1',
'startdate': nu.strftime("%Y-%m-%d"), 'startdate': nu.strftime("%Y-%m-%d"),
'enddate': targetdate.strftime("%Y-%m-%d"), 'enddate': targetdate.strftime("%Y-%m-%d"),
'active': True, 'active': True,
} }
newplanform = TrainingPlanForm(form_data,user=self.u) newplanform = TrainingPlanForm(form_data,user=self.u)
self.assertTrue(newplanform.is_valid()) self.assertTrue(newplanform.is_valid())
response = self.c.post(url,form_data) response = self.c.post(url,form_data)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
urlplan = '/rowers/plan/1/' urlplan = '/rowers/plan/1/'
response = self.c.get(urlplan) response = self.c.get(urlplan)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
html = BeautifulSoup(response.content,'html.parser') html = BeautifulSoup(response.content,'html.parser')
urls = [a['href'] for a in html.find_all('a')] urls = [a['href'] for a in html.find_all('a')]
for url in urls: for url in urls:
if 'macrocycle' in url and 'delete' not in url: if 'macrocycle' in url and 'delete' not in url:
macrourl = url macrourl = url
print(macrourl) print(macrourl)
response = self.c.get(macrourl) response = self.c.get(macrourl)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
form_data = { form_data = {
'name':faker.word(), 'name':faker.word(),
'startdate':nu.strftime("%Y-%m-%d"), 'startdate':nu.strftime("%Y-%m-%d"),
'enddate':targetdate.strftime("%Y-%m-%d"), 'enddate':targetdate.strftime("%Y-%m-%d"),
'notes':faker.text(), 'notes':faker.text(),
} }
macroform = TrainingMacroCycleForm(form_data) macroform = TrainingMacroCycleForm(form_data)
self.assertTrue(macroform.is_valid()) self.assertTrue(macroform.is_valid())
response = self.c.post(macrourl,form_data,follow=True) response = self.c.post(macrourl,form_data,follow=True)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
self.assertRedirects(response, self.assertRedirects(response,
expected_url='/rowers/plan/1/macro/3/', expected_url='/rowers/plan/1/macro/3/',
status_code=302,target_status_code=200) status_code=302,target_status_code=200)
response = self.c.get(urlplan) response = self.c.get(urlplan)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
html = BeautifulSoup(response.content,'html.parser') html = BeautifulSoup(response.content,'html.parser')
urls = [a['href'] for a in html.find_all('a')] urls = [a['href'] for a in html.find_all('a')]
for url in urls: for url in urls:
if 'planbymonths' in url: if 'planbymonths' in url:
print(url) print(url)
response = self.c.get(url,follow=True) response = self.c.get(url,follow=True)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
response = self.c.get('/rowers/plan/1/macro/3/') response = self.c.get('/rowers/plan/1/macro/3/')
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
html = BeautifulSoup(response.content,'html.parser') html = BeautifulSoup(response.content,'html.parser')
urls = [a['href'] for a in html.find_all('a')] urls = [a['href'] for a in html.find_all('a')]
tested = False tested = False
for url in urls: for url in urls:
if 'planbyweeks' in url and not tested: if 'planbyweeks' in url and not tested:
response = self.c.get(url,follow=True) response = self.c.get(url,follow=True)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
tested = True tested = True
# add test for creating new sessions # add test for creating new sessions
def test_sessions_create(self): def test_sessions_create(self):
with transaction.atomic():
login = self.c.login(username=self.u.username, password=self.password) login = self.c.login(username=self.u.username, password=self.password)
self.assertTrue(login) self.assertTrue(login)
url = reverse('plannedsession_create_view') url = reverse('plannedsession_create_view')
startdate = nu.date() startdate = nu.date()
enddate = (nu+datetime.timedelta(days=3)).date() enddate = (nu+datetime.timedelta(days=3)).date()
preferreddate = startdate preferreddate = startdate
response = self.c.get(url) response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
post_data = { post_data = {
'comment': faker.text(), 'comment': faker.text(),
'criterium': 'none', 'criterium': 'none',
'enddate': enddate.strftime("%Y-%m-%d"), 'enddate': enddate.strftime("%Y-%m-%d"),
'preferreddate': preferreddate.strftime("%Y-%m-%d"), 'preferreddate': preferreddate.strftime("%Y-%m-%d"),
'startdate': startdate.strftime("%Y-%m-%d"), 'startdate': startdate.strftime("%Y-%m-%d"),
'sessionmode':'time', 'sessionmode':'time',
'sessiontype':'session', 'sessiontype':'session',
'sessionunit':'min', 'sessionunit':'min',
'sessionvalue': '60', 'sessionvalue': '60',
'name': faker.word(), 'name': faker.word(),
} }
print('posting to sessions/create') print('posting to sessions/create')
form = PlannedSessionForm(post_data) form = PlannedSessionForm(post_data)
self.assertTrue(form.is_valid()) self.assertTrue(form.is_valid())
response = self.c.post(url,post_data) response = self.c.post(url,post_data)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
@@ -220,122 +223,124 @@ class SessionLinkTest(TestCase):
pass pass
def test_plannedsessions(self): def test_plannedsessions(self):
login = self.c.login(username=self.u.username, password=self.password) with transaction.atomic():
self.assertTrue(login) login = self.c.login(username=self.u.username, password=self.password)
self.assertTrue(login)
w = self.user_workouts[0] w = self.user_workouts[0]
startdatetime = w.startdatetime startdatetime = w.startdatetime
startdate = (startdatetime-datetime.timedelta(days=1)).date() startdate = (startdatetime-datetime.timedelta(days=1)).date()
enddate = (startdatetime+datetime.timedelta(days=1)).date() enddate = (startdatetime+datetime.timedelta(days=1)).date()
url = '/rowers/sessions/' url = '/rowers/sessions/'
response = self.c.get(url) response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
post_data = { post_data = {
'startdate':startdate.strftime("%Y-%m-%d"), 'startdate':startdate.strftime("%Y-%m-%d"),
'enddate': enddate.strftime("%Y-%m-%d"), 'enddate': enddate.strftime("%Y-%m-%d"),
}
response = self.c.post(url,post_data)
self.assertEqual(response.status_code,200)
url2 = '/rowers/sessions/manage/'
response = self.c.get(url2,post_data)
self.assertEqual(response.status_code,200)
pss = PlannedSession.objects.filter(startdate=startdate,enddate=enddate)
self.assertTrue(len(pss)>0)
ps = pss[0]
post_data = {
'plannedsession': str(ps.id),
'workouts':[str(w.id)],
} }
plannedsessionstuple = [] response = self.c.post(url,post_data)
for ps in pss: self.assertEqual(response.status_code,200)
sessiontpl = (ps.id,ps.__str__())
plannedsessionstuple.append(sessiontpl)
plannedsessionstuple = tuple(plannedsessionstuple) url2 = '/rowers/sessions/manage/'
response = self.c.get(url2,post_data)
self.assertEqual(response.status_code,200)
pss = PlannedSession.objects.filter(startdate=startdate,enddate=enddate)
self.assertTrue(len(pss)>0)
ps = pss[0]
post_data = {
'plannedsession': str(ps.id),
'workouts':[str(w.id)],
}
plannedsessionstuple = []
for ps in pss:
sessiontpl = (ps.id,ps.__str__())
plannedsessionstuple.append(sessiontpl)
plannedsessionstuple = tuple(plannedsessionstuple)
url2 += '?startdate={startdate}&enddate={enddate}'.format( url2 += '?startdate={startdate}&enddate={enddate}'.format(
startdate=startdate.strftime("%Y-%m-%d"), startdate=startdate.strftime("%Y-%m-%d"),
enddate = enddate.strftime("%Y-%m-%d"), enddate = enddate.strftime("%Y-%m-%d"),
) )
workoutdata = {} workoutdata = {}
workoutdata['initial'] = [] workoutdata['initial'] = []
choices = [] choices = []
for w in self.user_workouts: for w in self.user_workouts:
wtpl = (w.id,w.__str__()) wtpl = (w.id,w.__str__())
choices.append(wtpl) choices.append(wtpl)
workoutdata['choices'] = tuple(choices) workoutdata['choices'] = tuple(choices)
form = PlannedSessionSelectForm(plannedsessionstuple,post_data) form = PlannedSessionSelectForm(plannedsessionstuple,post_data)
self.assertTrue(form.is_valid()) self.assertTrue(form.is_valid())
form = WorkoutSessionSelectForm(workoutdata,post_data) form = WorkoutSessionSelectForm(workoutdata,post_data)
self.assertTrue(form.is_valid()) self.assertTrue(form.is_valid())
response = self.c.post(url2,post_data) response = self.c.post(url2,post_data)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
urlsession = '/rowers/sessions/{id}/'.format(id=ps.id) urlsession = '/rowers/sessions/{id}/'.format(id=ps.id)
response = self.c.get(urlsession) response = self.c.get(urlsession)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
url = '/rowers/sessions/coach/' url = '/rowers/sessions/coach/'
response = self.c.get(url) response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
def test_multiplesessions(self): def test_multiplesessions(self):
login = self.c.login(username=self.u.username, password=self.password) with transaction.atomic():
self.assertTrue(login) login = self.c.login(username=self.u.username, password=self.password)
self.assertTrue(login)
pss = PlannedSession.objects.all() pss = PlannedSession.objects.all()
earliestdate = min([ps.startdate for ps in pss]) earliestdate = min([ps.startdate for ps in pss])
latestdate = max([ps.enddate for ps in pss]) latestdate = max([ps.enddate for ps in pss])
url = '/rowers/sessions/multicreate/?when={be}/{en}'.format( url = '/rowers/sessions/multicreate/?when={be}/{en}'.format(
be = earliestdate.strftime("%Y-%m-%d"), be = earliestdate.strftime("%Y-%m-%d"),
en = latestdate.strftime("%Y-%m-%d"), en = latestdate.strftime("%Y-%m-%d"),
) )
response = self.c.get(url) response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
url = '/rowers/sessions/multicreate/user/{userid}/extra/1/?when={be}/{en}'.format( url = '/rowers/sessions/multicreate/user/{userid}/extra/1/?when={be}/{en}'.format(
be = earliestdate.strftime("%Y-%m-%d"), be = earliestdate.strftime("%Y-%m-%d"),
en = latestdate.strftime("%Y-%m-%d"), en = latestdate.strftime("%Y-%m-%d"),
userid = self.u.id userid = self.u.id
) )
response = self.c.get(url) response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
url = '/rowers/sessions/multiclone/user/{userid}/?when={be}/{en}'.format( url = '/rowers/sessions/multiclone/user/{userid}/?when={be}/{en}'.format(
be = earliestdate.strftime("%Y-%m-%d"), be = earliestdate.strftime("%Y-%m-%d"),
en = latestdate.strftime("%Y-%m-%d"), en = latestdate.strftime("%Y-%m-%d"),
userid = self.u.id userid = self.u.id
) )
response = self.c.get(url) response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
# 2019-01-13, rScore 69, # 2019-01-13, rScore 69,
@@ -456,144 +461,146 @@ class SessionCompleteTest(TestCase):
pass pass
def test_session1_complete(self): def test_session1_complete(self):
with transaction.atomic():
result = plannedsessions.add_workouts_plannedsession( result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_rscore,self.r [self.w1],self.ps_rscore,self.r
)
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_rscore
)
self.assertEqual(verdict,'on target')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_dist,self.r
) )
ratio,verdict,completiondate = plannedsessions.is_session_complete( ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_dist self.r,self.ps_rscore
)
self.assertEqual(verdict,'on target')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_time,self.r
) )
ratio,verdict,completiondate = plannedsessions.is_session_complete( self.assertEqual(verdict,'on target')
self.r,self.ps_time
)
self.assertEqual(verdict,'on target') result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_dist,self.r
)
result = plannedsessions.add_workouts_plannedsession( ratio,verdict,completiondate = plannedsessions.is_session_complete(
[self.w1],self.ps_trimp,self.r self.r,self.ps_dist
) )
ratio,verdict,completiondate = plannedsessions.is_session_complete( self.assertEqual(verdict,'on target')
self.r,self.ps_trimp
)
self.assertEqual(verdict,'on target')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_time,self.r
)
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_time
)
self.assertEqual(verdict,'on target')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_trimp,self.r
)
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_trimp
)
self.assertEqual(verdict,'on target')
def test_session_comment(self): def test_session_comment(self):
login = self.c.login(username=self.u.username, password=self.password) with transaction.atomic():
self.assertTrue(login) login = self.c.login(username=self.u.username, password=self.password)
self.assertTrue(login)
url = reverse('plannedsession_comment_view',kwargs={'id':self.ps_rscore.id}) url = reverse('plannedsession_comment_view',kwargs={'id':self.ps_rscore.id})
response = self.c.get(url) response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
form_data = { form_data = {
'comment': faker.text() 'comment': faker.text()
} }
form = WorkoutCommentForm(form_data) form = WorkoutCommentForm(form_data)
self.assertTrue(form.is_valid()) self.assertTrue(form.is_valid())
response = self.c.post(url,form_data,follow=True) response = self.c.post(url,form_data,follow=True)
self.assertEqual(response.status_code,200) self.assertEqual(response.status_code,200)
def test_session1_exact_complete(self): def test_session1_exact_complete(self):
self.ps_rscore.criterium = 'exact' with transaction.atomic():
self.ps_rscore.save() self.ps_rscore.criterium = 'exact'
self.ps_rscore.save()
self.ps_dist.criterium = 'exact' self.ps_dist.criterium = 'exact'
self.ps_dist.save() self.ps_dist.save()
self.ps_time.criterium = 'exact' self.ps_time.criterium = 'exact'
self.ps_time.save() self.ps_time.save()
self.ps_trimp.criterium = 'exact' self.ps_trimp.criterium = 'exact'
self.ps_trimp.save() self.ps_trimp.save()
result = plannedsessions.add_workouts_plannedsession( result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_rscore,self.r [self.w1],self.ps_rscore,self.r
)
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_rscore
)
self.assertEqual(verdict,'on target')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_dist,self.r
) )
ratio,verdict,completiondate = plannedsessions.is_session_complete( ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_dist self.r,self.ps_rscore
)
self.assertEqual(verdict,'on target')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_time,self.r
) )
ratio,verdict,completiondate = plannedsessions.is_session_complete( self.assertEqual(verdict,'on target')
self.r,self.ps_time
)
self.assertEqual(verdict,'partial') result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_dist,self.r
)
result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time) ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_dist
self.assertEqual(result,1)
result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
self.assertEqual(result,0)
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_trimp,self.r
) )
self.assertEqual(verdict,'on target')
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_trimp
)
self.assertEqual(verdict,'on target')
login = self.c.login(username=self.u.username, password=self.password) result = plannedsessions.add_workouts_plannedsession(
self.assertTrue(login) [self.w1],self.ps_time,self.r
)
url = '/rowers/sessions/{id}/'.format(id=self.ps_trimp.id) ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_time
)
response = self.c.get(url) self.assertEqual(verdict,'partial')
self.assertEqual(response.status_code,200)
url = '/rowers/sessions/' result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
response = self.c.get(url)
self.assertEqual(response.status_code,200) self.assertEqual(result,1)
result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
self.assertEqual(result,0)
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_trimp,self.r
)
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_trimp
)
self.assertEqual(verdict,'on target')
login = self.c.login(username=self.u.username, password=self.password)
self.assertTrue(login)
url = '/rowers/sessions/{id}/'.format(id=self.ps_trimp.id)
response = self.c.get(url)
self.assertEqual(response.status_code,200)
url = '/rowers/sessions/'
response = self.c.get(url)
self.assertEqual(response.status_code,200)
@override_settings(TESTING=True) @override_settings(TESTING=True)
@@ -711,47 +718,47 @@ class ChallengeCompleteTest(TestCase):
pass pass
def test_challenge1_complete(self): def test_challenge1_complete(self):
with transaction.atomic():
result = plannedsessions.add_workouts_plannedsession( result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_rscore,self.r [self.w1],self.ps_rscore,self.r
)
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_rscore
)
self.assertEqual(verdict,'partial')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_dist,self.r
) )
ratio,verdict,completiondate = plannedsessions.is_session_complete( ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_dist self.r,self.ps_rscore
)
self.assertEqual(verdict,'partial')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_time,self.r
) )
ratio,verdict,completiondate = plannedsessions.is_session_complete( self.assertEqual(verdict,'partial')
self.r,self.ps_time
)
self.assertEqual(verdict,'partial') result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_dist,self.r
)
result = plannedsessions.add_workouts_plannedsession( ratio,verdict,completiondate = plannedsessions.is_session_complete(
[self.w1],self.ps_trimp,self.r self.r,self.ps_dist
) )
ratio,verdict,completiondate = plannedsessions.is_session_complete( self.assertEqual(verdict,'partial')
self.r,self.ps_trimp
)
self.assertEqual(verdict,'partial')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_time,self.r
)
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_time
)
self.assertEqual(verdict,'partial')
result = plannedsessions.add_workouts_plannedsession(
[self.w1],self.ps_trimp,self.r
)
ratio,verdict,completiondate = plannedsessions.is_session_complete(
self.r,self.ps_trimp
)
self.assertEqual(verdict,'partial')

15
rowers/views/planviews.py
View File

@@ -468,11 +468,11 @@ def plannedsession_create_view(request,
ps.save() ps.save()
#if sessioncreateform.cleaned_data['fitfile']: if sessioncreateform.cleaned_data['fitfile']:
# f = sessioncreateform.cleaned_data['fitfile'] f = sessioncreateform.cleaned_data['fitfile']
# filename, path_and_filename = handle_uploaded_file(f) filename, path_and_filename = handle_uploaded_file(f)
# ps.fitfile.name = filename ps.fitfile.name = filename
# ps.save() ps.save()
add_rower_session(r,ps) add_rower_session(r,ps)
@@ -790,6 +790,11 @@ def plannedsession_teamcreate_view(request,
manager=request.user) manager=request.user)
ps.save() ps.save()
if fitfile:
f = sessioncreateform.cleaned_data['fitfile']
filename, path_and_filename = handle_uploaded_file(f)
ps.fitfile.name = filename
ps.save()
cd = sessionteamselectform.cleaned_data cd = sessionteamselectform.cleaned_data
teams = cd['team'] teams = cd['team']