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

more pep

Browse Source
This commit is contained in:
Sander Roosendaal
2022-02-16 13:21:58 +01:00
parent 4f48901c55
commit 984198e63c
2 changed files with 263 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

349
rowers/templatetags/rowerfilters.py
View File

@@ -1,3 +1,5 @@
from datetime import date
from django import template from django import template
from django.utils.safestring import mark_safe from django.utils.safestring import mark_safe
from time import strftime from time import strftime
@@ -7,44 +9,47 @@ import json
import math import math
import datetime import datetime
import re import re
register = template.Library()
from rowers.utils import calculate_age from rowers.utils import calculate_age
from rowers.models import ( from rowers.models import (
course_length,WorkoutComment, course_length, WorkoutComment,
TrainingMacroCycle,TrainingMesoCycle, TrainingMicroCycle, TrainingMacroCycle, TrainingMesoCycle, TrainingMicroCycle,
Rower,Workout,SiteAnnouncement, TeamInvite, TeamRequest, CoachOffer,CoachRequest, Rower, Workout, SiteAnnouncement, TeamInvite, TeamRequest, CoachOffer, CoachRequest,
VirtualRaceFollower,VirtualRace,favanalysischoices VirtualRaceFollower, VirtualRace, favanalysischoices,
) Team, TrainingPlan, TrainingTarget)
from rowers.plannedsessions import ( from rowers.plannedsessions import (
race_can_register, race_can_submit,race_rower_status race_can_register, race_can_submit, race_rower_status)
) from rowers.models import PlannedSession
from rowers.teams import coach_getcoachees
from rowers import credits from rowers import credits
from rowers import c2stuff from rowers import c2stuff
from rowers.c2stuff import c2_open from rowers.c2stuff import c2_open
from rowers.rower_rules import is_coach_user, is_workout_user, isplanmember,ispromember from rowers.rower_rules import is_coach_user, is_workout_user, isplanmember, ispromember
from rowers.mytypes import ( from rowers.mytypes import (
otwtypes,adaptivetypes,sexcategories,weightcategories,workouttypes, otwtypes, adaptivetypes, sexcategories, weightcategories, workouttypes,
workouttypes_icons, workouttypes_icons)
)
from rowers.utils import NoTokenError, step_to_string, landingpages2 from rowers.utils import NoTokenError, step_to_string, landingpages2
from rowers.teams import rower_get_managers
import rowers.payments as payments import rowers.payments as payments
from rowsandall_app.settings import NK_VIEWER_LOCATION from rowsandall_app.settings import NK_VIEWER_LOCATION
from rowers.opaque import encoder from rowers.opaque import encoder
from rowers.plannedsessions import ps_dict_get_description_html from rowers.plannedsessions import ps_dict_get_description_html
import arrow import arrow
from django.utils.safestring import mark_safe
from django.utils.html import urlize as urlize_impl from django.utils.html import urlize as urlize_impl
from django.template.defaultfilters import stringfilter from django.template.defaultfilters import stringfilter
from six import string_types from six import string_types
register = template.Library()
@register.filter @register.filter
def workoutdate(id): # pragma: no cover def workoutdate(id): # pragma: no cover
try: try:
@@ -53,8 +58,9 @@ def workoutdate(id): # pragma: no cover
except Workout.DoesNotExist: except Workout.DoesNotExist:
return 'unknown' return 'unknown'
@register.filter @register.filter
def isfollower(user,id): def isfollower(user, id):
if user.is_anonymous: # pragma: no cover if user.is_anonymous: # pragma: no cover
return True return True
@@ -63,13 +69,13 @@ def isfollower(user,id):
except VirtualRace.DoesNotExist: # pragma: no cover except VirtualRace.DoesNotExist: # pragma: no cover
return False return False
followers = VirtualRaceFollower.objects.filter(race=race,user=user) followers = VirtualRaceFollower.objects.filter(race=race, user=user)
return followers.count() == 0
return followers.count()==0
favanalysisdict = {} favanalysisdict = {}
for key,value in favanalysischoices: for key, value in favanalysischoices:
favanalysisdict[key] = value favanalysisdict[key] = value
landingpagedict = {} landingpagedict = {}
@@ -77,17 +83,18 @@ for key, value in landingpages2:
landingpagedict[key] = value landingpagedict[key] = value
landingpageicons = { landingpageicons = {
'workout_view':'fas fa-search fa-fw', 'workout_view': 'fas fa-search fa-fw',
'workout_edit_view':'fas fa-pencil-alt fa-fw', 'workout_edit_view': 'fas fa-pencil-alt fa-fw',
'workout_workflow_view':'fas fa-tachometer-alt fa-fw', 'workout_workflow_view': 'fas fa-tachometer-alt fa-fw',
'workout_stats_view':'fal fa-table fa-fw', 'workout_stats_view': 'fal fa-table fa-fw',
'workout_data_view':'fal fa-table fa-fw', 'workout_data_view': 'fal fa-table fa-fw',
'workout_summary_edit_view':'fas fa-pause fa-fw', 'workout_summary_edit_view': 'fas fa-pause fa-fw',
'workout_flexchart_stacked_view':'fas fa-align-justify fa-fw', 'workout_flexchart_stacked_view': 'fas fa-align-justify fa-fw',
'workout_flexchart3_view':'fas fa-chart-line fa-fw', 'workout_flexchart3_view': 'fas fa-chart-line fa-fw',
'workout_delete':'fas fa-trash-alt fa-fw' 'workout_delete': 'fas fa-trash-alt fa-fw'
} }
@register.filter @register.filter
def landingicon(landingpage): def landingicon(landingpage):
try: try:
@@ -95,11 +102,13 @@ def landingicon(landingpage):
except KeyError: # pragma: no cover except KeyError: # pragma: no cover
return 'fas fa-search fa-fw' return 'fas fa-search fa-fw'
@register.filter @register.filter
def steptostring(steps): def steptostring(steps):
res = ps_dict_get_description_html(steps,short=True) res = ps_dict_get_description_html(steps, short=True)
return res return res
# for verbose version of fav analysis # for verbose version of fav analysis
@register.filter @register.filter
def verbose(s): def verbose(s):
@@ -108,21 +117,24 @@ def verbose(s):
except KeyError: # pragma: no cover except KeyError: # pragma: no cover
return 'Details' return 'Details'
@register.filter @register.filter
def datarows(data): # pragma: no cover def datarows(data): # pragma: no cover
return range(len(data)) return range(len(data))
@register.filter @register.filter
def adaptive(s): def adaptive(s):
u = s u = s
for e,v in adaptivetypes: for e, v in adaptivetypes:
if e.lower() == u.lower(): if e.lower() == u.lower():
u = v u = v
continue continue
return u return u
@register.filter @register.filter
def nkviewerlink(workout): # pragma: no cover def nkviewerlink(workout): # pragma: no cover
url = "{nkviewer}{nkid}".format( url = "{nkviewer}{nkid}".format(
@@ -136,63 +148,69 @@ def nkviewerlink(workout): # pragma: no cover
def boatclass(s): def boatclass(s):
u = s u = s
for e,v in workouttypes: for e, v in workouttypes:
if e.lower() == u.lower(): if e.lower() == u.lower():
u = v u = v
continue continue
return u return u
@register.filter @register.filter
def sex(s): def sex(s):
u = s u = s
for e,v in sexcategories: for e, v in sexcategories:
if e.lower() == u.lower(): if e.lower() == u.lower():
u = v u = v
continue continue
return u return u
@register.filter @register.filter
def weekbegin(nr): def weekbegin(nr):
week, day = divmod(nr,7) week, day = divmod(nr, 7)
if day == 1: if day == 1:
return True return True
return False return False
@register.filter @register.filter
def discount(amount,rower): # pragma: no cover def discount(amount, rower): # pragma: no cover
return credits.discount(amount,rower) return credits.discount(amount, rower)
@register.filter @register.filter
def discounted(amount,rower): def discounted(amount, rower):
return credits.discounted(amount,rower) return credits.discounted(amount, rower)
@register.filter @register.filter
def weekend(nr): def weekend(nr):
week, day = divmod(nr,7) week, day = divmod(nr, 7)
if day == 0: if day == 0:
return True return True
return False return False
@register.filter @register.filter
def weight(s): def weight(s):
u = s u = s
for e,v in weightcategories: for e, v in weightcategories:
if e.lower() == u.lower(): if e.lower() == u.lower():
u = v u = v
continue continue
return u return u
@register.filter @register.filter
def sigdig(value, digits = 3): def sigdig(value, digits=3):
try: try:
order = int(math.floor(math.log10(math.fabs(value)))) order = int(math.floor(math.log10(math.fabs(value))))
except (ValueError,TypeError): # pragma: no cover except (ValueError, TypeError): # pragma: no cover
return value return value
# return integers as is # return integers as is
@@ -207,6 +225,7 @@ def sigdig(value, digits = 3):
fmtstr = "%.0f" fmtstr = "%.0f"
return fmtstr % (round(value, places)) # pragma: no cover return fmtstr % (round(value, places)) # pragma: no cover
@register.filter @register.filter
def pickle(dc): # pragma: no cover def pickle(dc): # pragma: no cover
s = dict() s = dict()
@@ -215,75 +234,83 @@ def pickle(dc): # pragma: no cover
return s return s
@register.filter(is_safe=True, needs_autoescape=True) @register.filter(is_safe=True, needs_autoescape=True)
@stringfilter @stringfilter
def urlshorten(value, limit,autoescape=None): def urlshorten(value, limit, autoescape=None):
return mark_safe( return mark_safe(
urlize_impl( urlize_impl(
value, trim_url_limit=int(limit), value, trim_url_limit=int(limit),
nofollow=True, autoescape=autoescape).replace('<a', '<a target="_blank"')) nofollow=True, autoescape=autoescape).replace('<a', '<a target="_blank"'))
@register.filter @register.filter
def nogoals(user): def nogoals(user):
targets = TrainingTarget.objects.filter(rowers=user.rower, targets = TrainingTarget.objects.filter(rowers=user.rower,
date__gte=datetime.date.today()) date__gte=datetime.date.today())
return len(targets)==0 return len(targets) == 0
@register.filter @register.filter
def notfree(rower): def notfree(rower):
return rower.rowerplan not in ['basic','freecoach'] return rower.rowerplan not in ['basic', 'freecoach']
def strfdelta(tdelta): def strfdelta(tdelta):
minutes,seconds = divmod(tdelta.seconds,60) minutes, seconds = divmod(tdelta.seconds, 60)
tenths = int(tdelta.microseconds/1e5) tenths = int(tdelta.microseconds/1e5)
res = "{minutes:0>1}:{seconds:0>2}.{tenths:0>1}".format( res = "{minutes:0>1}:{seconds:0>2}.{tenths:0>1}".format(
minutes=minutes, minutes=minutes,
seconds=seconds, seconds=seconds,
tenths=tenths, tenths=tenths)
)
return res return res
from rowers.teams import rower_get_managers
@register.filter @register.filter
def alertstatspercentage(list,i): # pragma: no cover def alertstatspercentage(list, i): # pragma: no cover
alertstats = list[i-1] alertstats = list[i-1]
return alertstats["percentage"] return alertstats["percentage"]
@register.filter @register.filter
def alertstartdate(list,i): # pragma: no cover def alertstartdate(list, i): # pragma: no cover
alertstats = list[i-1] alertstats = list[i-1]
return alertstats["startdate"] return alertstats["startdate"]
@register.filter @register.filter
def alertnperiod(list,i): # pragma: no cover def alertnperiod(list, i): # pragma: no cover
alertstats = list[i-1] alertstats = list[i-1]
return alertstats["nperiod"] return alertstats["nperiod"]
@register.filter @register.filter
def alertenddate(list,i): # pragma: no cover def alertenddate(list, i): # pragma: no cover
alertstats = list[i-1] alertstats = list[i-1]
return alertstats["enddate"] return alertstats["enddate"]
@register.filter @register.filter
def is_coach(rower,rowers): def is_coach(rower, rowers):
for r in rowers: for r in rowers:
if rower not in rower_get_managers(r): if rower not in rower_get_managers(r):
return False return False
return True return True
@register.filter @register.filter
def waterpower(x,rower): # pragma: no cover def waterpower(x, rower): # pragma: no cover
if rower is not None: if rower is not None:
return int(x*(100-rower.otwslack)/100.) return int(x*(100-rower.otwslack)/100.)
return int(x) return int(x)
@register.filter @register.filter
def round20(x): # pragma: no cover def round20(x): # pragma: no cover
try: try:
@@ -291,6 +318,7 @@ def round20(x): # pragma: no cover
except ValueError: except ValueError:
return 20 return 20
@register.filter @register.filter
def round100(x): # pragma: no cover def round100(x): # pragma: no cover
try: try:
@@ -298,49 +326,52 @@ def round100(x): # pragma: no cover
except ValueError: except ValueError:
return 100 return 100
@register.filter @register.filter
def majorticks(maxval): # pragma: no cover def majorticks(maxval): # pragma: no cover
ticks = range(1+int(maxval/100.)) ticks = range(1+int(maxval/100.))
newticks =[] newticks = []
for t in ticks: for t in ticks:
newticks.append(t*100) newticks.append(t*100)
return newticks return newticks
@register.filter @register.filter
def hrmajorticks(maxval,minval): # pragma: no cover def hrmajorticks(maxval, minval): # pragma: no cover
ticks = range(int((maxval-minval)/20.)-1) ticks = range(int((maxval-minval)/20.)-1)
newticks =[] newticks = []
for t in ticks: for t in ticks:
newticks.append(100+t*20) newticks.append(100+t*20)
return newticks return newticks
def strfdeltah(tdelta): def strfdeltah(tdelta):
hours, rest = divmod(tdelta.seconds,3600) hours, rest = divmod(tdelta.seconds, 3600)
minutes,seconds = divmod(rest,60) minutes, seconds = divmod(rest, 60)
tenths = int(tdelta.microseconds/1e5) tenths = int(tdelta.microseconds/1e5)
res = "{hours:0>2}:{minutes:0>2}:{seconds:0>2}.{tenths:0>1}".format( res = "{hours:0>2}:{minutes:0>2}:{seconds:0>2}.{tenths:0>1}".format(
hours=hours, hours=hours,
minutes=minutes, minutes=minutes,
seconds=seconds, seconds=seconds,
tenths=tenths, tenths=tenths)
)
return res return res
@register.filter @register.filter
def secondstotimestring(tdelta): def secondstotimestring(tdelta):
hours, rest = divmod(tdelta,3600) hours, rest = divmod(tdelta, 3600)
minutes,seconds = divmod(rest,60) minutes, seconds = divmod(rest, 60)
res = "{hours:0>2}:{minutes:0>2}:{seconds:0>2}".format( res = "{hours:0>2}:{minutes:0>2}:{seconds:0>2}".format(
hours=hours, hours=hours,
minutes=minutes, minutes=minutes,
seconds=seconds, seconds=seconds)
)
return res return res
@register.filter @register.filter
def existing_customer(user): def existing_customer(user):
if user.is_anonymous: # pragma: no cover if user.is_anonymous: # pragma: no cover
@@ -348,6 +379,7 @@ def existing_customer(user):
else: else:
return payments.is_existing_customer(user.rower) return payments.is_existing_customer(user.rower)
@register.filter @register.filter
def aantalcomments(workout): def aantalcomments(workout):
try: try:
@@ -359,6 +391,7 @@ def aantalcomments(workout):
return aantalcomments return aantalcomments
@register.filter @register.filter
def encode(id): def encode(id):
try: try:
@@ -367,6 +400,7 @@ def encode(id):
result = '' result = ''
return result return result
@register.filter @register.filter
def water(workout): def water(workout):
try: try:
@@ -374,25 +408,29 @@ def water(workout):
except AttributeError: # pragma: no cover except AttributeError: # pragma: no cover
return False return False
@register.filter @register.filter
def ddays(ddelta): def ddays(ddelta):
return ddelta.days+1 return ddelta.days+1
@register.filter @register.filter
def spacetohtml(t): def spacetohtml(t):
return t.replace(" ","%20") return t.replace(" ", "%20")
@register.filter @register.filter
def distanceprint(d): def distanceprint(d):
if d<10000: if d < 10000:
return "{d} m".format(d=d) return "{d} m".format(d=d)
d2 = d/1000. # pragma: no cover d2 = d / 1000. # pragma: no cover
return "%.2f km" % d2 # pragma: no cover return "%.2f km" % d2 # pragma: no cover
@register.filter @register.filter
def durationprint(d,dstring): def durationprint(d, dstring):
if (d == None): # pragma: no cover if (d is None): # pragma: no cover
return d return d
else: else:
try: try:
@@ -400,16 +438,18 @@ def durationprint(d,dstring):
except AttributeError: except AttributeError:
return None return None
def getstartenddate(timeperiod): def getstartenddate(timeperiod):
s,e = timeperiod.split('/') s, e = timeperiod.split('/')
startdate = arrow.get(s).date() startdate = arrow.get(s).date()
enddate = arrow.get(e).date() enddate = arrow.get(e).date()
return startdate,enddate return startdate, enddate
@register.filter @register.filter
def nextperiodend(timeperiod): def nextperiodend(timeperiod):
startdate,enddate = getstartenddate(timeperiod) startdate, enddate = getstartenddate(timeperiod)
timedelta = enddate-startdate timedelta = enddate-startdate
newstartdate = enddate+datetime.timedelta(days=1) newstartdate = enddate+datetime.timedelta(days=1)
newenddate = newstartdate+timedelta newenddate = newstartdate+timedelta
@@ -419,52 +459,53 @@ def nextperiodend(timeperiod):
@register.filter @register.filter
def nextperiodstart(timeperiod): def nextperiodstart(timeperiod):
startdate,enddate = getstartenddate(timeperiod) startdate, enddate = getstartenddate(timeperiod)
timedelta = enddate-startdate
newstartdate = enddate+datetime.timedelta(days=1) newstartdate = enddate+datetime.timedelta(days=1)
newenddate = newstartdate+timedelta
return newstartdate.strftime("%Y-%m-%d") return newstartdate.strftime("%Y-%m-%d")
@register.filter @register.filter
def previousperiodend(timeperiod): def previousperiodend(timeperiod):
startdate,enddate = getstartenddate(timeperiod) startdate, enddate = getstartenddate(timeperiod)
timedelta = enddate-startdate
newenddate = startdate-datetime.timedelta(days=1) newenddate = startdate-datetime.timedelta(days=1)
newstartdate = startdate-timedelta-datetime.timedelta(days=1)
return newenddate.strftime("%Y-%m-%d") return newenddate.strftime("%Y-%m-%d")
@register.filter @register.filter
def timedeltadays(timeperiod): def timedeltadays(timeperiod):
startdate,enddate = getstartenddate(timeperiod) startdate, enddate = getstartenddate(timeperiod)
timedelta = enddate-startdate timedelta = enddate-startdate
return timedelta.days+1 return timedelta.days+1
@register.filter @register.filter
def previousperiodstart(timeperiod): def previousperiodstart(timeperiod):
startdate,enddate = getstartenddate(timeperiod) startdate, enddate = getstartenddate(timeperiod)
timedelta = enddate-startdate timedelta = enddate-startdate
newenddate = startdate-datetime.timedelta(days=1)
newstartdate = startdate-timedelta-datetime.timedelta(days=1) newstartdate = startdate-timedelta-datetime.timedelta(days=1)
return newstartdate.strftime("%Y-%m-%d") return newstartdate.strftime("%Y-%m-%d")
@register.filter @register.filter
def paceprint(d): def paceprint(d):
if (d == None): # pragma: no cover if (d is None): # pragma: no cover
return d return d
else: else:
return strfdelta(d) return strfdelta(d)
@register.filter @register.filter
def deltatimeprint(d): # pragma: no cover def deltatimeprint(d): # pragma: no cover
if (d == None): if (d is None):
return d return d
else: else:
return strfdeltah(d) return strfdeltah(d)
@register.filter @register.filter
def c2userid(user): # pragma: no cover def c2userid(user): # pragma: no cover
try: try:
@@ -476,6 +517,7 @@ def c2userid(user): # pragma: no cover
return c2userid return c2userid
@register.filter @register.filter
def currency(word): def currency(word):
try: try:
@@ -490,11 +532,13 @@ def currency(word):
def courselength(course): # pragma: no cover def courselength(course): # pragma: no cover
return course_length(course) return course_length(course)
@register.filter(is_safe=True) @register.filter(is_safe=True)
def jsdict(dict,key): # pragma: no cover def jsdict(dict, key): # pragma: no cover
s = dict.get(key) s = dict.get(key)
return mark_safe(json.dumps(s)) return mark_safe(json.dumps(s))
@register.filter @register.filter
def icon(workouttype): def icon(workouttype):
try: try:
@@ -514,10 +558,11 @@ def lookup(dict, key):
except KeyError: # pragma: no cover except KeyError: # pragma: no cover
return None return None
if isinstance(s,string_types) and len(s) > 22: if isinstance(s, string_types) and len(s) > 22:
s = s[:22] s = s[:22]
return s return s
@register.filter @register.filter
def lookuplong(dict, key): def lookuplong(dict, key):
try: try:
@@ -528,9 +573,8 @@ def lookuplong(dict, key):
return s return s
from rowers.models import PlannedSession
@register.filter @register.filter
def is_session_manager(id,user): def is_session_manager(id, user):
try: try:
ps = PlannedSession.objects.get(id=id) ps = PlannedSession.objects.get(id=id)
except PlannedSession.DoesNotExist: # pragma: no cover except PlannedSession.DoesNotExist: # pragma: no cover
@@ -540,61 +584,62 @@ def is_session_manager(id,user):
@register.filter @register.filter
def may_edit(workout,request): def may_edit(workout, request):
mayedit = 0 mayedit = 0
if request.user == workout.user.user: if request.user == workout.user.user:
mayedit = True mayedit = True
if is_workout_user(request.user,workout): if is_workout_user(request.user, workout):
mayedit = True mayedit = True
return mayedit return mayedit
@register.filter @register.filter
def mayeditplan(obj,request): def mayeditplan(obj, request):
if obj is None: # pragma: no cover if obj is None: # pragma: no cover
return False return False
if hasattr(obj,'plan'): if hasattr(obj, 'plan'):
return mayeditplan(obj.plan,request) return mayeditplan(obj.plan, request)
if hasattr(obj,'manager'): if hasattr(obj, 'manager'):
if obj.manager is not None: if obj.manager is not None:
return request.user == obj.manager.user return request.user == obj.manager.user
rr = Rower.objects.get(user=request.user) # pragma: no cover rr = Rower.objects.get(user=request.user) # pragma: no cover
if is_coach_user(request.user,obj.rower) and rr.rowerplan not in ['basic','pro']: # pragma: no cover if is_coach_user(request.user, obj.rower) and rr.rowerplan not in ['basic', 'pro']: # pragma: no cover
mayedit = True mayedit = True
return mayedit # pragma: no cover return mayedit # pragma: no cover
@register.filter @register.filter
def iterrows(df): # pragma: no cover def iterrows(df): # pragma: no cover
return df.iterrows() return df.iterrows()
@register.filter(name='times') @register.filter(name='times')
def times(number): # pragma: no cover def times(number): # pragma: no cover
return range(number) return range(number)
@register.simple_tag
def get_df_iloc(data,i,j): # pragma: no cover
return data.iloc(i,j)
@register.simple_tag @register.simple_tag
def get_field_id(id,s,form): # pragma: no cover def get_df_iloc(data, i, j): # pragma: no cover
return data.iloc(i, j)
@register.simple_tag
def get_field_id(id, s, form): # pragma: no cover
field_name = s+str(id) field_name = s+str(id)
return form.__getitem__(field_name) return form.__getitem__(field_name)
from rowers.models import Rower,Team,TrainingPlan,TrainingTarget
@register.filter @register.filter
def is_promember(user): def is_promember(user):
return ispromember(user) return ispromember(user)
@register.filter @register.filter
def is_manager(user): def is_manager(user):
r = Rower.objects.get(user=user) r = Rower.objects.get(user=user)
@@ -605,6 +650,7 @@ def is_manager(user):
def is_planmember(user): def is_planmember(user):
return isplanmember(user) return isplanmember(user)
@register.filter @register.filter
def get_age(r): # pragma: no cover def get_age(r): # pragma: no cover
return calculate_age(r.birthdate) return calculate_age(r.birthdate)
@@ -622,6 +668,7 @@ def user_teams(user):
return teams return teams
@register.filter @register.filter
def user_team1(user): def user_team1(user):
try: try:
@@ -634,29 +681,31 @@ def user_team1(user):
return teams[0].id return teams[0].id
@register.filter @register.filter
def announcements(request): def announcements(request):
announcements = SiteAnnouncement.objects.filter( announcements = SiteAnnouncement.objects.filter(
expires__gte=datetime.date.today()).order_by( expires__gte=datetime.date.today()).order_by(
"-created", "-created",
"-id" "-id")
)
return announcements[0:4] return announcements[0:4]
@register.filter @register.filter
def has_teams(user): # pragma: no cover def has_teams(user): # pragma: no cover
try: try:
therower = Rower.objects.get(user=user) therower = Rower.objects.get(user=user)
teams1 = therower.team.all() teams1 = therower.team.all()
teams2 = Team.objects.filter(manager=user) teams2 = Team.objects.filter(manager=user)
teams = list(set(teams1).union(set(teams2))) _ = list(set(teams1).union(set(teams2)))
return True return True
except TypeError: except TypeError:
return False return False
return False return False
@register.filter @register.filter
def team_members(user): def team_members(user):
try: try:
@@ -665,16 +714,16 @@ def team_members(user):
return [] return []
teams = Team.objects.filter(manager=user) teams = Team.objects.filter(manager=user)
members = Rower.objects.filter( members = Rower.objects.filter(
team__in=teams team__in=teams).distinct().order_by(
).distinct().order_by( "user__last_name", "user__first_name").exclude(
"user__last_name","user__first_name" rowerplan='freecoach')
).exclude(rowerplan='freecoach')
return [rower.user for rower in members] return [rower.user for rower in members]
except TypeError: # pragma: no cover except TypeError: # pragma: no cover
return [] return []
return [] # pragma: no cover return [] # pragma: no cover
@register.filter @register.filter
def openactions(user): def openactions(user):
myteams = Team.objects.filter(manager=user) myteams = Team.objects.filter(manager=user)
@@ -698,16 +747,16 @@ def team_rowers(user): # pragma: no cover
if therower.rowerplan == 'basic': if therower.rowerplan == 'basic':
return [] return []
teams = Team.objects.filter(manager=user) teams = Team.objects.filter(manager=user)
members = Rower.objects.filter(team__in=teams).distinct().order_by( members = Rower.objects.filter(
"user__last_name","user__last_name" team__in=teams).distinct().order_by(
).exclude(rowerplan='freecoach') "user__last_name", "user__last_name").exclude(
rowerplan='freecoach')
return members return members
except TypeError: except TypeError:
return [] return []
return [] return []
from rowers.teams import coach_getcoachees
@register.filter @register.filter
def coach_rowers(user): def coach_rowers(user):
@@ -721,7 +770,7 @@ def coach_rowers(user):
@register.filter @register.filter
def verbosetimeperiod(timeperiod): # pragma: no cover def verbosetimeperiod(timeperiod): # pragma: no cover
table = { table = {
'today':'Today', 'today': 'Today',
'thisweek': 'This Week', 'thisweek': 'This Week',
'thismonth': 'This Month', 'thismonth': 'This Month',
'lastmonth': 'Last Month', 'lastmonth': 'Last Month',
@@ -737,7 +786,6 @@ def verbosetimeperiod(timeperiod): # pragma: no cover
return verbose return verbose
from datetime import date
@ register.filter @ register.filter
def future_date_only(the_date): # pragma: no cover def future_date_only(the_date): # pragma: no cover
@@ -751,16 +799,16 @@ def future_date_only(the_date): # pragma: no cover
def is_future_date(the_date): def is_future_date(the_date):
return the_date >= date.today() return the_date >= date.today()
@register.filter @register.filter
def amount(value): def amount(value):
vs = '{v}.00'.format(v=int(value)) vs = '{v}.00'.format(v=int(value))
return vs return vs
@register.filter @register.filter
def date_dif(the_date): def date_dif(the_date):
if the_date == date(1970,1,1): if the_date == date(1970, 1, 1):
return 1 return 1
if the_date: if the_date:
return the_date - date.today() return the_date - date.today()
@@ -769,94 +817,105 @@ def date_dif(the_date):
@register.filter @register.filter
def can_register(race,r): def can_register(race, r):
return race_can_register(r,race) return race_can_register(r, race)
@register.filter @register.filter
def can_submit(race,r): # pragma: no cover def can_submit(race, r): # pragma: no cover
return race_can_submit(r,race) return race_can_submit(r, race)
@register.filter @register.filter
def race_complete(race,r): # pragma: no cover def race_complete(race, r): # pragma: no cover
is_complete,has_registered = race_rower_status(r,race) is_complete, has_registered = race_rower_status(r, race)
return is_complete return is_complete
@register.filter
def past_not_registered(race,r): # pragma: no cover
is_complete,has_registered = race_rower_status(r,race)
return not has_registered
@register.filter @register.filter
def future_registered(race,r): # pragma: no cover def past_not_registered(race, r): # pragma: no cover
is_complete, has_registered = race_rower_status(r,race) is_complete, has_registered = race_rower_status(r, race)
return not has_registered
@register.filter
def future_registered(race, r): # pragma: no cover
is_complete, has_registered = race_rower_status(r, race)
is_open = race.evaluation_closure > timezone.now() is_open = race.evaluation_closure > timezone.now()
return has_registered and not is_complete and is_open return has_registered and not is_complete and is_open
@property @property
def is_past_due(self): # pragma: no cover def is_past_due(self): # pragma: no cover
return datetime.date.today() > self.date return datetime.date.today() > self.date
@property @property
def is_not_past_due(self): # pragma: no cover def is_not_past_due(self): # pragma: no cover
return datetime.date.today() <= self.date return datetime.date.today() <= self.date
@register.filter @register.filter
def is_closed(race): # pragma: no cover def is_closed(race): # pragma: no cover
return race.evaluation_closure < timezone.now() return race.evaluation_closure < timezone.now()
@register.filter @register.filter
def is_final(race): # pragma: no cover def is_final(race): # pragma: no cover
return race.evaluation_closure < timezone.now()-datetime.timedelta(hours=1) return race.evaluation_closure < timezone.now()-datetime.timedelta(hours=1)
@register.filter @register.filter
def userurl(path,member): def userurl(path, member):
pattern = re.compile('user\/\d+/') pattern = re.compile('user\/\d+/')
userstring = 'user/%s/' % member.id userstring = 'user/%s/' % member.id
# remove team # remove team
tpattern = re.compile('team\/\d+/') tpattern = re.compile('team\/\d+/')
if tpattern.search(path) is not None: if tpattern.search(path) is not None:
path = tpattern.sub('',path) path = tpattern.sub('', path)
if pattern.search(path) is not None: if pattern.search(path) is not None:
replaced = pattern.sub(userstring,path) replaced = pattern.sub(userstring, path)
else: else:
replaced = path+userstring replaced = path+userstring
return replaced return replaced
@register.filter @register.filter
def teamurl(path,team): def teamurl(path, team):
pattern = re.compile('team\/\d+/') pattern = re.compile('team\/\d+/')
teamstring = 'team/%s/' % team.id teamstring = 'team/%s/' % team.id
# remove user # remove user
upattern = re.compile('\/user\/\d+/') upattern = re.compile('\/user\/\d+/')
if upattern.search(path) is not None: if upattern.search(path) is not None:
path = upattern.sub('/',path) path = upattern.sub('/', path)
if pattern.search(path) is not None: if pattern.search(path) is not None:
replaced = pattern.sub(teamstring,path) replaced = pattern.sub(teamstring, path)
else: else:
replaced = path+teamstring replaced = path+teamstring
return replaced return replaced
@register.filter @register.filter
def timeurl(path,timestring): # pragma: no cover def timeurl(path, timestring): # pragma: no cover
pattern = re.compile('\?when=w.*') pattern = re.compile('\?when=w.*')
timeurl = '?when=%s' % timestring timeurl = '?when=%s' % timestring
replaced = '' replaced = ''
if pattern.search(path) is not None: if pattern.search(path) is not None:
replaced = pattern.sub(timeurl,path) replaced = pattern.sub(timeurl, path)
if not replaced: if not replaced:
replaced = path+timeurl replaced = path+timeurl
return replaced return replaced
@register.filter @register.filter
def trainingplans(rower): def trainingplans(rower):
today = datetime.date.today() today = datetime.date.today()
@@ -868,6 +927,7 @@ def trainingplans(rower):
return plans return plans
@register.filter @register.filter
def mesomacroid(id): # pragma: no cover def mesomacroid(id): # pragma: no cover
try: try:
@@ -879,6 +939,7 @@ def mesomacroid(id): # pragma: no cover
return str(theid) return str(theid)
@register.filter @register.filter
def micromesoid(id): # pragma: no cover def micromesoid(id): # pragma: no cover
try: try:
@@ -902,8 +963,9 @@ def micromacroid(id): # pragma: no cover
return str(theid) return str(theid)
@register.filter @register.filter
def nextworkout(workout,user): def nextworkout(workout, user):
if user.rower == workout.user: if user.rower == workout.user:
try: try:
ws = Workout.objects.filter( ws = Workout.objects.filter(
@@ -918,7 +980,7 @@ def nextworkout(workout,user):
try: try:
ws = Workout.objects.filter( ws = Workout.objects.filter(
startdatetime__gt=workout.startdatetime, startdatetime__gt=workout.startdatetime,
user=workout.user,privacy='visible' user=workout.user, privacy='visible'
).order_by( ).order_by(
"startdatetime" "startdatetime"
).exclude(id=workout.id) ).exclude(id=workout.id)
@@ -931,9 +993,8 @@ def nextworkout(workout,user):
return 0 return 0
@register.filter @register.filter
def previousworkout(workout,user): def previousworkout(workout, user):
if user.rower == workout.user: if user.rower == workout.user:
try: try:
ws = Workout.objects.filter( ws = Workout.objects.filter(
@@ -948,7 +1009,7 @@ def previousworkout(workout,user):
try: try:
ws = Workout.objects.filter( ws = Workout.objects.filter(
startdatetime__lt=workout.startdatetime, startdatetime__lt=workout.startdatetime,
user=workout.user,privacy='visible' user=workout.user, privacy='visible'
).order_by( ).order_by(
"-startdatetime" "-startdatetime"
).exclude(id=workout.id) ).exclude(id=workout.id)

1
tox.ini
View File

@@ -1,3 +1,4 @@
[flake8] [flake8]
ignore = F405, F403, E722, E226, W504, F401, W605 ignore = F405, F403, E722, E226, W504, F401, W605
max-line-length = 120 max-line-length = 120
exclude = .git, rowers/migrations