commit

rowers/teams.py

@@ -1,4 +1,23 @@
 from __future__ import absolute_import
+from rowers.rower_rules import is_team_manager, is_team_member, is_coach, user_is_basic
+from rowers.models import ValidationError, PlannedSession
+from rowers.tasks import (
+    handle_sendemail_invite,
+    handle_sendemail_request,
+    handle_sendemail_member_dropped, handle_sendemail_request_accept,
+    handle_sendemail_request_reject, handle_sendemail_invite_reject,
+    handle_sendemail_invite_accept, handle_sendemail_team_removed,
+    handle_sendemail_coachrequest, handle_sendemail_coacheerequest,
+    handle_sendemail_coachoffer_rejected,
+    handle_sendemail_coachoffer_accepted,
+    handle_sendemail_coachrequest_rejected,
+    handle_sendemail_coachrequest_accepted,
+    handle_sendemail_message,
+)
+from rowers.models import (
+    Rower, Workout, Team, TeamInvite, User, TeamRequest, CoachRequest, CoachOffer,
+    CoachingGroup
+)
 from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
@@ -22,50 +41,31 @@ queue = django_rq.get_queue('default')
 queuelow = django_rq.get_queue('low')
 queuehigh = django_rq.get_queue('low')
 
-from rowers.models import (
-    Rower, Workout, Team, TeamInvite,User,TeamRequest, CoachRequest, CoachOffer,
-    CoachingGroup
-    )
-
-from rowers.rower_rules import is_team_manager,is_team_member,is_coach, user_is_basic
-
-from rowers.tasks import (
-    handle_sendemail_invite,
-    handle_sendemail_request,
-    handle_sendemail_member_dropped,handle_sendemail_request_accept,
-    handle_sendemail_request_reject,handle_sendemail_invite_reject,
-    handle_sendemail_invite_accept,handle_sendemail_team_removed,
-    handle_sendemail_coachrequest,handle_sendemail_coacheerequest,
-    handle_sendemail_coachoffer_rejected,
-    handle_sendemail_coachoffer_accepted,
-    handle_sendemail_coachrequest_rejected,
-    handle_sendemail_coachrequest_accepted,
-    handle_sendemail_message,
-    )
-
-from rowers.models import ValidationError, PlannedSession
 
 # Low level functions - to be called by higher level methods
 
-inviteduration = 14 # days
+inviteduration = 14  # days
 
-def handle_remove_workouts_team(ws,t):
+
+def handle_remove_workouts_team(ws, t):
     for w in ws:
         w.team.remove(t)
 
     return 1
 
-def handle_add_workouts_team(ws,t):
+
+def handle_add_workouts_team(ws, t):
 
     for w in ws:
         w.team.add(t)
 
     return 1
 
-def update_team(t,name,manager,private,notes,viewing):
 
-    if not is_team_manager(manager,t):
-        return (0,'You are not the manager of this team')
+def update_team(t, name, manager, private, notes, viewing):
+
+    if not is_team_manager(manager, t):
+        return (0, 'You are not the manager of this team')
     try:
         t.name = name
         t.manager = manager
@@ -74,93 +74,100 @@ def update_team(t,name,manager,private,notes,viewing):
         t.viewing = viewing
         t.save()
     except IntegrityError:
-        return (0,'Team name duplication')
-    return (1,'Team Updated')
+        return (0, 'Team name duplication')
+    return (1, 'Team Updated')
 
-def create_team(name,manager,private='open',notes='',viewing='allmembers'):
+
+def create_team(name, manager, private='open', notes='', viewing='allmembers'):
     # needs some error testing
-    if user_is_basic(manager.rower.user): # pragma: no cover
-        return (0,'You need to upgrade to a paid plan to establish a team')
+    if user_is_basic(manager.rower.user):  # pragma: no cover
+        return (0, 'You need to upgrade to a paid plan to establish a team')
     if not is_coach(manager):
         ts = Team.objects.filter(manager=manager)
-        if len(ts)>=1: # pragma: no cover
-            return (0,'You need to upgrade to the Coach plan to have more than one team')
+        if len(ts) >= 1:  # pragma: no cover
+            return (0, 'You need to upgrade to the Coach plan to have more than one team')
 
     try:
-        t = Team(name=name,manager=manager,notes=notes,
-                 private=private,viewing=viewing)
+        t = Team(name=name, manager=manager, notes=notes,
+                 private=private, viewing=viewing)
         t.save()
         r = Rower.objects.get(user=manager)
-        res = add_member(t.id,r)
+        res = add_member(t.id, r)
     except IntegrityError:
-        return (0,'Team name duplication')
-    return (t.id,'Team created')
+        return (0, 'Team name duplication')
+    return (t.id, 'Team created')
+
 
 def remove_team(id):
     t = Team.objects.get(id=id)
     for r in Rower.objects.filter(team=t):
-        send_team_delete_mail(t,r)
+        send_team_delete_mail(t, r)
     return t.delete()
 
-    return (1,'Updated rower team expiry') # pragma: no cover
+    return (1, 'Updated rower team expiry')  # pragma: no cover
 
-def add_coach(coach,rower):
+
+def add_coach(coach, rower):
     # get coaching group
 
     coachgroup = coach.mycoachgroup
-    if coachgroup is None: # pragma: no cover
+    if coachgroup is None:  # pragma: no cover
         coachgroup = CoachingGroup(name=coach.user.first_name)
         coachgroup.save()
         coach.mycoachgroup = coachgroup
         coach.save()
 
-    if get_coach_club_size(coach)<coach.clubsize:
+    if get_coach_club_size(coach) < coach.clubsize:
         rower.coachinggroups.add(coach.mycoachgroup)
 
-        return (1,"Added Coach")
-    else: # pragma: no cover
-        return (0,"Maximum number of athletes reached")
+        return (1, "Added Coach")
+    else:  # pragma: no cover
+        return (0, "Maximum number of athletes reached")
 
-def add_member(id,rower):
-    t= Team.objects.get(id=id)
+
+def add_member(id, rower):
+    t = Team.objects.get(id=id)
     try:
         rower.team.add(t)
-    except ValidationError as e: # pragma: no cover
-        return(0,"Couldn't add member: "+str(e.message))
+    except ValidationError as e:  # pragma: no cover
+        return(0, "Couldn't add member: "+str(e.message))
 
     # code to add all workouts
     ws = Workout.objects.filter(user=rower)
 
-    res = handle_add_workouts_team(ws,t)
+    res = handle_add_workouts_team(ws, t)
 
     # code to add plannedsessions
-    plannedsessions = PlannedSession.objects.filter(team=t,enddate__gte=timezone.now().date())
-    for ps in plannedsessions: # pragma: no cover
+    plannedsessions = PlannedSession.objects.filter(
+        team=t, enddate__gte=timezone.now().date())
+    for ps in plannedsessions:  # pragma: no cover
         res = ps.rower.add(rower)
 
 #    set_teamplanexpires(rower)
     # code for Stuck At Home Team (temporary)
-    if id == 52 and rower.rowerplan == 'basic': # pragma: no cover
-        rower.protrialexpires = ddate(2020,9,1)
+    if id == 52 and rower.rowerplan == 'basic':  # pragma: no cover
+        rower.protrialexpires = ddate(2020, 9, 1)
         rower.save()
 
-    return (id,'Member added')
+    return (id, 'Member added')
 
-def remove_member(id,rower):
+
+def remove_member(id, rower):
     t = Team.objects.get(id=id)
     rower.team.remove(t)
     # remove the team from rower's workouts:
-    ws = Workout.objects.filter(user=rower,team=t)
+    ws = Workout.objects.filter(user=rower, team=t)
 
-    res = handle_remove_workouts_team(ws,t)
+    res = handle_remove_workouts_team(ws, t)
 
 #    set_teamplanexpires(rower)
-    return (id,'Member removed')
+    return (id, 'Member removed')
 
-def remove_coach(coach,rower): # pragma: no cover
+
+def remove_coach(coach, rower):  # pragma: no cover
     try:
         coachgroup = coach.mycoachgroup
-    except CoachingGroup.DoesNotExist: # pragma: no cover
+    except CoachingGroup.DoesNotExist:  # pragma: no cover
         coachgroup = CoachingGroup()
         coachgroup.save()
         coach.mycoachgroup = coachgroup
@@ -168,7 +175,8 @@ def remove_coach(coach,rower): # pragma: no cover
 
     rower.coachinggroups.remove(coachgroup)
 
-    return (1,'Coach removed')
+    return (1, 'Coach removed')
+
 
 def rower_get_managers(rower):
     managers = []
@@ -177,6 +185,7 @@ def rower_get_managers(rower):
 
     return managers
 
+
 def rower_get_coaches(rower):
     return rower.get_coaches()
 
@@ -184,18 +193,19 @@ def rower_get_coaches(rower):
 def coach_getcoachees(coach):
     rowers = []
     if coach.mycoachgroup and is_coach(coach.user):
-        rs =  Rower.objects.filter(
+        rs = Rower.objects.filter(
             coachinggroups__in=[coach.mycoachgroup]
-        ).distinct().order_by("user__last_name","user__first_name")
+        ).distinct().order_by("user__last_name", "user__first_name")
         for r in rs:
             rowers.append(r)
 
     return rowers
 
-def coach_remove_athlete(coach,rower):
+
+def coach_remove_athlete(coach, rower):
     try:
         coachgroup = coach.mycoachgroup
-    except CoachingGroup.DoesNotExist: # pragma: no cover
+    except CoachingGroup.DoesNotExist:  # pragma: no cover
         coachgroup = CoachingGroup()
         coachgroup.save()
         coach.mycoachgroup = coachgroup
@@ -203,20 +213,22 @@ def coach_remove_athlete(coach,rower):
 
     rower.coachinggroups.remove(coachgroup)
 
-    return (1,'Coach removed')
+    return (1, 'Coach removed')
 
-def mgr_remove_member(id,manager,rower):
+
+def mgr_remove_member(id, manager, rower):
     t = Team.objects.get(id=id)
-    if is_team_manager(manager,t):
-        remove_member(id,rower)
-        send_email_member_dropped(id,rower)
-        return (id,'Member removed')
-    else: # pragma: no cover
-        return (0,'You are not the team manager')
+    if is_team_manager(manager, t):
+        remove_member(id, rower)
+        send_email_member_dropped(id, rower)
+        return (id, 'Member removed')
+    else:  # pragma: no cover
+        return (0, 'You are not the team manager')
 
-    return (0,'') # pragma: no cover
+    return (0, '')  # pragma: no cover
 
-def count_invites(manager): # pragma: no cover
+
+def count_invites(manager):  # pragma: no cover
     ts = Team.objects.filter(manager=manager)
     count = 0
     for t in ts:
@@ -225,7 +237,7 @@ def count_invites(manager): # pragma: no cover
     return count
 
 
-def count_club_members(manager): # pragma: no cover
+def count_club_members(manager):  # pragma: no cover
     ts = Team.objects.filter(manager=manager)
     return Rower.objects.filter(team__in=ts).distinct().count()
 
@@ -233,25 +245,26 @@ def count_club_members(manager): # pragma: no cover
 # Medium level functionality
 
 # request by user to be coached by coach
-def create_coaching_request(coach,user): # pragma: no cover
+def create_coaching_request(coach, user):  # pragma: no cover
     if coach in rower_get_coaches(user.rower):
-        return (0,'Already coached by that coach')
+        return (0, 'Already coached by that coach')
 
     codes = [i.code for i in CoachRequest.objects.all()]
     code = uuid.uuid4().hex[:10].upper()
-    while code in codes: # pragma: no cover
+    while code in codes:  # pragma: no cover
         code = uuid.uuid4().hex[:10].upper()
 
     if 'coach' in coach.rowerplan:
-        rekwest = CoachRequest(coach=coach,user=user,code=code)
+        rekwest = CoachRequest(coach=coach, user=user, code=code)
         rekwest.save()
 
         send_coachrequest_email(rekwest)
 
-        return (rekwest.id,'The request was created')
+        return (rekwest.id, 'The request was created')
+
+    else:  # pragma: no cover
+        return (0, 'That person is not a coach')
 
-    else: # pragma: no cover
-        return (0,'That person is not a coach')
 
 def send_coachrequest_email(rekwest):
     name = rekwest.user.first_name + " " + rekwest.user.last_name
@@ -263,7 +276,8 @@ def send_coachrequest_email(rekwest):
 
     res = myqueue(queuehigh,
                   handle_sendemail_coachrequest,
-                  email,name,code,coachname)
+                  email, name, code, coachname)
+
 
 def send_coacheerequest_email(rekwest):
     name = rekwest.user.first_name + " " + rekwest.user.last_name
@@ -275,30 +289,32 @@ def send_coacheerequest_email(rekwest):
 
     res = myqueue(queuehigh,
                   handle_sendemail_coacheerequest,
-                  email,name,code,coachname)
+                  email, name, code, coachname)
 
-def create_request(team,user):
+
+def create_request(team, user):
     r2 = Rower.objects.get(user=user)
     r = Rower.objects.get(user=team.manager)
-    if r2 in Rower.objects.filter(team=team): # pragma: no cover
-        return (0,'Already a member of that team')
+    if r2 in Rower.objects.filter(team=team):  # pragma: no cover
+        return (0, 'Already a member of that team')
 
     #    if count_club_members(team.manager)+count_invites(team.manager) <= r.clubsize:
     codes = [i.code for i in TeamRequest.objects.all()]
     code = uuid.uuid4().hex[:10].upper()
     # prevent duplicates
-    while code in codes: # pragma: no cover
+    while code in codes:  # pragma: no cover
         code = uuid.uuid4().hex[:10].upper()
 
     u = User.objects.get(id=user)
-    rekwest = TeamRequest(team=team,user=u,code=code)
+    rekwest = TeamRequest(team=team, user=u, code=code)
     rekwest.save()
 
     send_request_email(rekwest)
 
-    return (rekwest.id,'The request was created')
+    return (rekwest.id, 'The request was created')
+
+    return (0, 'Something went wrong in create_request')  # pragma: no cover
 
-    return (0,'Something went wrong in create_request') # pragma: no cover
 
 def get_coach_club_size(coach):
     rs = Rower.objects.filter(coachinggroups__in=[coach.mycoachgroup])
@@ -310,181 +326,185 @@ def get_coach_club_size(coach):
 
 
 # request by coach to coach user
-def create_coaching_offer(coach,user):
+def create_coaching_offer(coach, user):
     r = user.rower
 
-    if coach in rower_get_coaches(user.rower): # pragma: no cover
-        return (0,'You are already coaching this person.')
+    if coach in rower_get_coaches(user.rower):  # pragma: no cover
+        return (0, 'You are already coaching this person.')
 
     codes = [i.code for i in CoachOffer.objects.all()]
     code = uuid.uuid4().hex[:10].upper()
-    while code in codes: # pragma: no cover
+    while code in codes:  # pragma: no cover
         code = uuid.uuid4().hex[:10].upper()
 
-    if 'coach' in coach.rowerplan and get_coach_club_size(coach)<coach.clubsize:
-        rekwest = CoachOffer(coach=coach,user=user,code=code)
+    if 'coach' in coach.rowerplan and get_coach_club_size(coach) < coach.clubsize:
+        rekwest = CoachOffer(coach=coach, user=user, code=code)
         rekwest.save()
 
         send_coacheerequest_email(rekwest)
 
-        return (rekwest.id,'The request was created')
-    elif get_coach_club_size(coach)>=coach.clubsize: # pragma: no cover
-        return(0,'You have reached the maximum number of athletes')
+        return (rekwest.id, 'The request was created')
+    elif get_coach_club_size(coach) >= coach.clubsize:  # pragma: no cover
+        return(0, 'You have reached the maximum number of athletes')
 
-    else: # pragma: no cover
-        return (0,'You are not a coach')
+    else:  # pragma: no cover
+        return (0, 'You are not a coach')
 
 
-
-
-def create_invite(team,manager,user=None,email=''):
+def create_invite(team, manager, user=None, email=''):
     r = Rower.objects.get(user=manager)
-    if not is_team_manager(manager,team):
-        return (0,'Not the team manager')
+    if not is_team_manager(manager, team):
+        return (0, 'Not the team manager')
     if user:
         try:
             r2 = Rower.objects.get(user=user)
             email = r2.user.email
-        except Rower.DoesNotExist: # pragma: no cover
-            return (0,'Rower does not exist')
+        except Rower.DoesNotExist:  # pragma: no cover
+            return (0, 'Rower does not exist')
         if r2 in Rower.objects.filter(team=team):
-            return (0,'Already member of that team')
-    elif email==None or email=='': # pragma: no cover
-        return (0,'Invalid request - missing email or user')
+            return (0, 'Already member of that team')
+    elif email == None or email == '':  # pragma: no cover
+        return (0, 'Invalid request - missing email or user')
     else:
         try:
             r2 = Rower.objects.get(user__email=email)
             user = User.objects.get(rower=r2)
-        except Rower.DoesNotExist: # pragma: no cover
-            user=None
-        except Rower.MultipleObjectsReturned: # pragma: no cover
-            return (0,'There is more than one user with that email address')
+        except Rower.DoesNotExist:  # pragma: no cover
+            user = None
+        except Rower.MultipleObjectsReturned:  # pragma: no cover
+            return (0, 'There is more than one user with that email address')
 
     #    if count_club_members(team.manager)+count_invites(team.manager) <= r.clubsize:
     codes = [i.code for i in TeamInvite.objects.all()]
     code = uuid.uuid4().hex[:10].upper()
     # prevent duplicates
-    while code in codes: # pragma: no cover
+    while code in codes:  # pragma: no cover
         code = uuid.uuid4().hex[:10].upper()
 
-    invite = TeamInvite(team=team,code=code,user=user,email=email)
+    invite = TeamInvite(team=team, code=code, user=user, email=email)
     invite.save()
-    return (invite.id,'Invitation created')
+    return (invite.id, 'Invitation created')
+
+    return (0, 'Nothing done')  # pragma: no cover
 
 
-    return (0,'Nothing done') # pragma: no cover
-
-def revoke_request(user,id):
+def revoke_request(user, id):
     try:
         rekwest = TeamRequest.objects.get(id=id)
-    except TeamRequest.DoesNotExist: # pragma: no cover
-        return (0,'The request is invalid')
+    except TeamRequest.DoesNotExist:  # pragma: no cover
+        return (0, 'The request is invalid')
 
     t = rekwest.team
 
-    if rekwest.user==user:
+    if rekwest.user == user:
         rekwest.delete()
-        return (1,'Request revoked')
-    else: # pragma: no cover
-        return (0,'You are not the requestor')
+        return (1, 'Request revoked')
+    else:  # pragma: no cover
+        return (0, 'You are not the requestor')
 
-def reject_revoke_coach_offer(user,id):
+
+def reject_revoke_coach_offer(user, id):
     try:
         rekwest = CoachOffer.objects.get(id=id)
-    except CoachOffer.DoesNotExist: # pragma: no cover
-        return (0,'The request is invalid')
+    except CoachOffer.DoesNotExist:  # pragma: no cover
+        return (0, 'The request is invalid')
 
     if rekwest.coach.user == user:
         rekwest.delete()
 
-        return (1,'Request removed')
+        return (1, 'Request removed')
     elif rekwest.user == user:
         send_coachoffer_rejected_email(rekwest)
         rekwest.delete()
-        return (1,'Request removed')
-    else: # pragma: no cover
-        return (0,'Not permitted')
+        return (1, 'Request removed')
+    else:  # pragma: no cover
+        return (0, 'Not permitted')
 
-def reject_revoke_coach_request(user,id):
+
+def reject_revoke_coach_request(user, id):
     try:
         rekwest = CoachRequest.objects.get(id=id)
-    except CoachRequest.DoesNotExist: # pragma: no cover
-        return (0,'The request is invalid')
+    except CoachRequest.DoesNotExist:  # pragma: no cover
+        return (0, 'The request is invalid')
 
     if rekwest.coach.user == user:
         send_coachrequest_rejected_email(rekwest)
         rekwest.delete()
-        return (1,'Request rejected')
+        return (1, 'Request rejected')
     elif rekwest.user == user:
         rekwest.delete()
-        return (1,'Request rejected')
-    else: # pragma: no cover
-        return (0,'Not permitted')
+        return (1, 'Request rejected')
+    else:  # pragma: no cover
+        return (0, 'Not permitted')
 
-def revoke_invite(manager,id):
+
+def revoke_invite(manager, id):
     try:
         invite = TeamInvite.objects.get(id=id)
-    except TeamInvite.DoesNotExist: # pragma: no cover
-        return (0,'The invitation is invalid')
+    except TeamInvite.DoesNotExist:  # pragma: no cover
+        return (0, 'The invitation is invalid')
 
-    if is_team_manager(manager,invite.team):
+    if is_team_manager(manager, invite.team):
         invite.delete()
-        return (1,'Invitation revoked')
-    else: # pragma: no cover
-        return (0,'You are not the team manager')
+        return (1, 'Invitation revoked')
+    else:  # pragma: no cover
+        return (0, 'You are not the team manager')
 
-def reject_request(manager,id):
+
+def reject_request(manager, id):
     try:
         rekwest = TeamRequest.objects.get(id=id)
-    except TeamRequest.DoesNotExist: # pragma: no cover
-        return (0,'The request is invalid')
+    except TeamRequest.DoesNotExist:  # pragma: no cover
+        return (0, 'The request is invalid')
 
-    if is_team_manager(manager,rekwest.team):
+    if is_team_manager(manager, rekwest.team):
         send_request_reject_email(rekwest)
         rekwest.delete()
-        return (1,'Request rejected')
-    else: # pragma: no cover
-        return (0,'You are not the manager for this request')
+        return (1, 'Request rejected')
+    else:  # pragma: no cover
+        return (0, 'You are not the manager for this request')
 
 
-def reject_invitation(user,id):
+def reject_invitation(user, id):
     try:
         invite = TeamInvite.objects.get(id=id)
-    except TeamInvite.DoesNotExist: # pragma: no cover
-        return (0,'The invitation is invalid')
+    except TeamInvite.DoesNotExist:  # pragma: no cover
+        return (0, 'The invitation is invalid')
 
-    if invite.user==user:
+    if invite.user == user:
         send_invite_reject_email(invite)
         invite.delete()
-        return (1,'Invitation rejected')
-    else: # pragma: no cover
-        return (0,'This request was not for you')
+        return (1, 'Invitation rejected')
+    else:  # pragma: no cover
+        return (0, 'This request was not for you')
 
 
 def send_invite_email(id):
     try:
         invitation = TeamInvite.objects.get(id=id)
-    except TeamInvite.DoesNotExist: # pragma: no cover
-        return (0,'Invitation doesn not exist')
+    except TeamInvite.DoesNotExist:  # pragma: no cover
+        return (0, 'Invitation doesn not exist')
 
     if invitation.user:
         email = invitation.user.email
         name = invitation.user.first_name + " " + invitation.user.last_name
-    else: # pragma: no cover
+    else:  # pragma: no cover
         email = invitation.email
         name = ''
 
     code = invitation.code
     teamname = invitation.team.name
-    manager = invitation.team.manager.first_name+' '+invitation.team.manager.last_name
+    manager = invitation.team.manager.first_name + \
+        ' '+invitation.team.manager.last_name
 
     res = myqueue(queuehigh,
                   handle_sendemail_invite,
-	          email,name,code,teamname,manager)
+                  email, name, code, teamname, manager)
 
-    return (1,'Invitation email sent')
+    return (1, 'Invitation email sent')
 
-def send_team_delete_mail(t,rower):
+
+def send_team_delete_mail(t, rower):
     u = rower.user
     teamname = t.name
     email = u.email
@@ -492,11 +512,12 @@ def send_team_delete_mail(t,rower):
     manager = t.manager.first_name+' '+t.manager.last_name
     res = myqueue(queuehigh,
                   handle_sendemail_team_removed,
-	          email,name,teamname,manager)
+                  email, name, teamname, manager)
 
-    return (1,'Team delete email sent')
+    return (1, 'Team delete email sent')
 
-def send_email_member_dropped(teamid,rower):
+
+def send_email_member_dropped(teamid, rower):
     t = Team.objects.get(id=teamid)
     u = rower.user
     teamname = t.name
@@ -504,13 +525,13 @@ def send_email_member_dropped(teamid,rower):
     name = u.first_name+' '+u.last_name
     manager = t.manager.first_name+' '+t.manager.last_name
 
-    res = myqueue(queuehigh,handle_sendemail_member_dropped,
-	          email,name,teamname,manager)
+    res = myqueue(queuehigh, handle_sendemail_member_dropped,
+                  email, name, teamname, manager)
 
-    return (1,'Member dropped email sent')
+    return (1, 'Member dropped email sent')
 
 
-def send_request_accept_email(rekwest): # pragma: no cover
+def send_request_accept_email(rekwest):  # pragma: no cover
     id = rekwest.id
     email = rekwest.user.email
     teamname = rekwest.team.name
@@ -518,9 +539,9 @@ def send_request_accept_email(rekwest): # pragma: no cover
     manager = rekwest.team.manager.first_name+' '+rekwest.team.manager.last_name
     res = myqueue(queuehigh,
                   handle_sendemail_request_accept,
-	          email,name,teamname,manager)
+                  email, name, teamname, manager)
 
-    return (1,'Invitation email sent')
+    return (1, 'Invitation email sent')
 
 
 def send_request_reject_email(rekwest):
@@ -532,9 +553,9 @@ def send_request_reject_email(rekwest):
 
     res = myqueue(queuehigh,
                   handle_sendemail_request_reject,
-	          email,name,teamname,manager)
+                  email, name, teamname, manager)
 
-    return (1,'Invitation email sent')
+    return (1, 'Invitation email sent')
 
 
 def send_invite_reject_email(invitation):
@@ -542,20 +563,21 @@ def send_invite_reject_email(invitation):
     email = invitation.team.manager.email
     if invitation.user:
         name = invitation.user.first_name+' '+invitation.user.last_name
-    else: # pragma: no cover
+    else:  # pragma: no cover
         name = invitation.email
 
     teamname = invitation.team.name
-    manager = invitation.team.manager.first_name+' '+invitation.team.manager.last_name
+    manager = invitation.team.manager.first_name + \
+        ' '+invitation.team.manager.last_name
 
     res = myqueue(queuehigh,
                   handle_sendemail_invite_reject,
-	          email,name,teamname,manager)
+                  email, name, teamname, manager)
 
-    return (1,'Invitation email sent')
+    return (1, 'Invitation email sent')
 
 
-def send_invite_accept_email(invitation): # pragma: no cover
+def send_invite_accept_email(invitation):  # pragma: no cover
     id = invitation.id
     email = invitation.team.manager.email
     if invitation.user:
@@ -564,15 +586,17 @@ def send_invite_accept_email(invitation): # pragma: no cover
         name = invitation.email
 
     teamname = invitation.team.name
-    manager = invitation.team.manager.first_name+' '+invitation.team.manager.last_name
+    manager = invitation.team.manager.first_name + \
+        ' '+invitation.team.manager.last_name
 
     res = myqueue(queuehigh,
                   handle_sendemail_invite_accept,
-	          email,name,teamname,manager)
+                  email, name, teamname, manager)
 
-    return (1,'Invitation email sent')
+    return (1, 'Invitation email sent')
 
-def send_team_message(team,message): # pragma: no cover
+
+def send_team_message(team, message):  # pragma: no cover
     rowers = team.rower.all()
     managername = team.manager.first_name + " " + team.manager.last_name
 
@@ -580,9 +604,10 @@ def send_team_message(team,message): # pragma: no cover
         rowername = rower.user.first_name + " " + rower.user.last_name
         res = myqueue(queuehigh,
                       handle_sendemail_message,
-                      rower.user.email,team.manager.email,rowername,message,team.name,managername)
+                      rower.user.email, team.manager.email, rowername, message, team.name, managername)
+
+    return (1, 'message sent')
 
-    return (1,'message sent')
 
 def send_request_email(rekwest):
     email = rekwest.team.manager.email
@@ -594,82 +619,83 @@ def send_request_email(rekwest):
 
     res = myqueue(queuehigh,
                   handle_sendemail_request,
-	          email,name,code,teamname,requestor,id)
+                  email, name, code, teamname, requestor, id)
 
-    return (1,'Invitation email sent')
+    return (1, 'Invitation email sent')
 
-def process_request_code(manager,code):  # pragma: no cover
+
+def process_request_code(manager, code):  # pragma: no cover
     code = code.upper()
 
     try:
         rekwest = TeamRequest.objects.get(code=code)
     except TeamRequest.DoesNotExist:
-        return (0,'The request has been revoked or the code is invalid')
+        return (0, 'The request has been revoked or the code is invalid')
 
     r = Rower.objects.get(user=rekwest.user)
     t = rekwest.team
 
     if rekwest.team.manager != manager:
-        return (0,'You are not the manager of this team')
+        return (0, 'You are not the manager of this team')
 
-    result,comment = add_member(t.id,r)
+    result, comment = add_member(t.id, r)
     if not result:
-        return (result,"The member couldn't be added")
-
+        return (result, "The member couldn't be added")
 
     send_request_accept_email(rekwest)
 
-
     rekwest.delete()
-    return (result,'The member was added')
+    return (result, 'The member was added')
 
-def process_invite_code(user,code): # pragma: no cover
+
+def process_invite_code(user, code):  # pragma: no cover
     code = code.upper()
     try:
         invitation = TeamInvite.objects.get(code=code)
     except TeamInvite.DoesNotExist:
-        return (0,'The invitation has expired or the code is invalid')
+        return (0, 'The invitation has expired or the code is invalid')
 
     r = Rower.objects.get(user=user)
     nu = datetime.date(timezone.now())
     if nu > invitation.issuedate+timedelta(days=inviteduration):
-        revoke_invite(invitation.team.manager,invitation.id)
-        return (0,'The invitation has expired')
+        revoke_invite(invitation.team.manager, invitation.id)
+        return (0, 'The invitation has expired')
 
     t = invitation.team
 
-    result, comment = add_member(t.id,r)
+    result, comment = add_member(t.id, r)
 
     if not result:
-        return (result,"The member couldn't be added")
-
+        return (result, "The member couldn't be added")
 
     send_invite_accept_email(invitation)
     invitation.delete()
-    return (result,'You were added to the team')
+    return (result, 'You were added to the team')
 
-def remove_expired_invites(): # pragma: no cover
+
+def remove_expired_invites():  # pragma: no cover
     issuedate = timezone.now()-timedelta(days=inviteduration)
     issuedate = datetime.date(issuedate)
     invitations = TeamInvite.objects.filter(issuedate__lt=issuedate)
     for i in invitations:
-        revoke_invite(i.team.manager,i.id)
+        revoke_invite(i.team.manager, i.id)
 
-    return (1,'Expired invitations deleted')
+    return (1, 'Expired invitations deleted')
 
-def process_coachrequest_code(coach,code):
+
+def process_coachrequest_code(coach, code):
     code = code.upper()
 
     try:
         rekwest = CoachRequest.objects.get(code=code)
-    except CoachRequest.DoesNotExist: # pragma: no cover
-        return (0,'The request has been revoked or is invalid')
+    except CoachRequest.DoesNotExist:  # pragma: no cover
+        return (0, 'The request has been revoked or is invalid')
 
-    if rekwest.coach != coach: # pragma: no cover
-        return (0,'The request is invalid')
+    if rekwest.coach != coach:  # pragma: no cover
+        return (0, 'The request is invalid')
 
-    result = add_coach(coach,rekwest.user.rower)
-    if not result: # pragma: no cover
+    result = add_coach(coach, rekwest.user.rower)
+    if not result:  # pragma: no cover
         return result
     else:
         send_coachrequest_accepted_email(rekwest)
@@ -678,19 +704,20 @@ def process_coachrequest_code(coach,code):
 
     return result
 
-def process_coachoffer_code(user,code):
+
+def process_coachoffer_code(user, code):
     code = code.upper()
 
     try:
         rekwest = CoachOffer.objects.get(code=code)
-    except CoachOffer.DoesNotExist: # pragma: no cover
-        return (0,'The request has been revoked or is invalid')
+    except CoachOffer.DoesNotExist:  # pragma: no cover
+        return (0, 'The request has been revoked or is invalid')
 
-    if rekwest.user != user: # pragma: no cover
-        return (0,'The request is invalid')
+    if rekwest.user != user:  # pragma: no cover
+        return (0, 'The request is invalid')
 
-    result = add_coach(rekwest.coach,rekwest.user.rower)
-    if not result: # pragma: no cover
+    result = add_coach(rekwest.coach, rekwest.user.rower)
+    if not result:  # pragma: no cover
         return result
     else:
         send_coachoffer_accepted_email(rekwest)
@@ -699,6 +726,7 @@ def process_coachoffer_code(user,code):
 
     return result
 
+
 def send_coachoffer_rejected_email(rekwest):
     coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name
     coachemail = rekwest.coach.user.email
@@ -707,7 +735,8 @@ def send_coachoffer_rejected_email(rekwest):
 
     res = myqueue(queuehigh,
                   handle_sendemail_coachoffer_rejected,
-                  coachemail,coachname,name)
+                  coachemail, coachname, name)
+
 
 def send_coachrequest_rejected_email(rekwest):
     coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name
@@ -717,7 +746,8 @@ def send_coachrequest_rejected_email(rekwest):
 
     res = myqueue(queuehigh,
                   handle_sendemail_coachrequest_rejected,
-                  email,coachname,name)
+                  email, coachname, name)
+
 
 def send_coachrequest_accepted_email(rekwest):
     coachname = rekwest.coach.user.first_name + " " + rekwest.coach.user.last_name
@@ -727,7 +757,7 @@ def send_coachrequest_accepted_email(rekwest):
 
     res = myqueue(queuehigh,
                   handle_sendemail_coachrequest_accepted,
-                  email,coachname,name)
+                  email, coachname, name)
 
 
 def send_coachoffer_accepted_email(rekwest):
@@ -738,4 +768,4 @@ def send_coachoffer_accepted_email(rekwest):
 
     res = myqueue(queuehigh,
                   handle_sendemail_coachoffer_accepted,
-                  coachemail,coachname,name)
+                  coachemail, coachname, name)