def get(self):
# Checks for active Google account session
user = users.get_current_user()
#Check if user is logged in
if user is None:
#Send html data to browser
template_values = {'logged_out': users.create_login_url('/')}
template = JINJA_ENVIRONMENT.get_template('templates/index.html')
self.response.write(template.render(template_values))
else:
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name
}
template = JINJA_ENVIRONMENT.get_template('templates/index.html')
self.response.write(template.render(template_values))
def remove_from_league(user_id):
"""
Remove a certain user_id from their league, only if the draft hasn't already started
"""
#Current user's id, used to identify their data
account = Account.get_or_insert(user_id)
if league_key(account.league).get() and league_key(
account.league).get().draft_current_position == 0:
#Remove user's choices and lineup for the league
choice = choice_key(account_key(user_id), account.league).get()
if choice:
lineup_query = Lineup.query(ancestor=choice.key).fetch()
for lineup in lineup_query:
lineup.key.delete()
choice.key.delete()
#If this is the last person in the league, or this is the commissioner, delete it after they leave
players = Account.query().filter(
Account.league == account.league).fetch()
if len(players) == 1 or account.league == account.key.id():
past_league = account.league
#Remove User's association with league
account.league = '0'
account.put()
delete_league(past_league)
#Remove User's association with league
account.league = '0'
account.put()
def get(self):
# Checks for active Google account session
user = users.get_current_user()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name
}
template = JINJA_ENVIRONMENT.get_template(
'templates/create_league.html')
self.response.write(template.render(template_values))
def get(self):
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
draft_over = league_key(league_id).get().draft_current_position == -1
if draft_over:
if league_id != '0':
league_name = league_key(league_id).get().name
else:
league_name = ""
total_points = 0
week_table = []
for weeknum in range(1, globals.number_of_official_weeks + 1):
teams = get_team_lists(user_id, weeknum)[0]
points = 0
lineup = []
for team in teams:
event_key = get_team_schedule(int(team['number']))[int(weeknum) - 1]['event_key']#-1 to convert to 0-based index
if event_key: #Check if the team is competing that week
points += get_team_points_at_event(team['number'], event_key)
lineup.append(team['number'])
if is_week_editable(weeknum):
points = "<i>No Data</i>"
else:
total_points += points
week_row = {'week': str(weeknum), 'active_lineup': lineup, 'points': points}
week_table.append(week_row)
leader_board = get_leader_board(league_id)
league_schedule = get_readable_schedule(league_id)
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'week_table': week_table,
'total_points': total_points,
'leader_board': leader_board,
'schedule': league_schedule,
}
template = JINJA_ENVIRONMENT.get_template('templates/alliance_management_portal.html')
self.response.write(template.render(template_values))
else:
template = JINJA_ENVIRONMENT.get_template('templates/error_page.html')
self.response.write(template.render({'Message':"This page requires that the draft be completed before accessing it"}))
def get(self, page):
"""
Display a certain page of the free agent list
:param page: The page to display
The free agent list is a list of teams that have not been drafted by any player.
They are sorted by the total points of each team
Users have the option to pick up teams or "flag" them to get updates about them
"""
# Checks for active Google account session
user = users.get_current_user()
logout_url = users.create_logout_url('/')
#Display update text for the status of the last choice update
update_text = self.request.get('updated')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
if not page:
page = 1
else:
page = int(page)
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
free_agent_list = get_free_agent_list(league_id, page)
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'update_text': update_text,
'free_agent_list': free_agent_list,
'page': page,
'max_page': get_max_free_agent_pages(league_id),
}
template = JINJA_ENVIRONMENT.get_template('templates/falist.html')
self.response.write(template.render(template_values))
else:
globals.display_error_page(
self, self.request.referer,
error_messages.need_to_be_a_member_of_a_league)
def get(self, page):
"""
Display a certain page of the free agent list
:param page: The page to display
The free agent list is a list of teams that have not been drafted by any player.
They are sorted by the total points of each team
Users have the option to pick up teams or "flag" them to get updates about them
"""
# Checks for active Google account session
user = users.get_current_user()
logout_url = users.create_logout_url('/')
#Display update text for the status of the last choice update
update_text = self.request.get('updated')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
if not page:
page = 1
else:
page = int(page)
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
free_agent_list = get_free_agent_list(league_id, page)
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'update_text': update_text,
'free_agent_list': free_agent_list,
'page': page,
'max_page': get_max_free_agent_pages(league_id),
}
template = JINJA_ENVIRONMENT.get_template('templates/falist.html')
self.response.write(template.render(template_values))
else:
globals.display_error_page(self, self.request.referer, error_messages.need_to_be_a_member_of_a_league)
def get(self):
# Checks for active Google account session
user = users.get_current_user()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
league_query = League.query()
league_list = league_query.fetch()
league_output = []
for league in league_list:
number_of_players = len(Account.query().filter(
Account.league == league.key.id()).fetch())
commissioner = "None"
if account_key(league.key.id()).get():
commissioner = account_key(league.key.id()).get().nickname
league_output.append({
'name':
league.name,
'id':
league.key.id(),
'size':
number_of_players,
'commissioner':
commissioner,
'join_url':
'/leagueManagement/joinLeague/' + league.key.id()
})
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_list': league_output,
'league_name': league_name
}
template = JINJA_ENVIRONMENT.get_template('templates/league_list.html')
self.response.write(template.render(template_values))
def get(self, week_number):
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
draft_over = league_key(league_id).get().draft_current_position == -1
if league_id != '0':
league_name = league_key(league_id).get().name
else:
league_name = ""
if draft_over:
team_lists = get_team_lists(user_id, week_number)
point_total = 0
for team in team_lists[0]:
point_total += team['total_points']
opponent_team_lists = get_team_lists(get_opponent(user_id, week_number), week_number)
opponent_point_total = 0
for team in opponent_team_lists[0]:
opponent_point_total += team['total_points']
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'week_number': int(week_number),
'point_totals': [point_total, opponent_point_total],
'team_listss': [team_lists, opponent_team_lists],
'opponent_name': get_opponent_name(user_id, week_number),
}
if is_week_editable(week_number):
template = JINJA_ENVIRONMENT.get_template('templates/alliance_management.html')
else:
template = JINJA_ENVIRONMENT.get_template('templates/past_alliances.html')
self.response.write(template.render(template_values))
else:
template = JINJA_ENVIRONMENT.get_template('templates/error_page.html')
self.response.write(template.render({'Message':"This page requires that the draft be completed before accessing it"}))
def close_draft(league_id):
"""
Preform all of the operations necessary to finish the drafting process
:param league_id: The league to do this in
Called at the end of the draft
Initialize lineup items
Generate schedule
"""
league = league_key(league_id).get()
league.draft_current_position = -1 # Indicate the draft is over
league.draft_current_timeout = None
league.put()
#Build a schedule
generate_schedule(league_id)
#Initialize requirements for bench/active system and distribute a schedule
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch()
for player in league_players:
#For the active system
choice = Choice.get_or_insert(league_id, parent=player.key)
for i in range(1, globals.number_of_official_weeks + 1):
initialize_lineup(i, choice) # Initialize weekly lineups
player.record.append('')
player.put()
def get(self):
"""
When visited by the league commissioner, the draft is started
The commissioner is then redirected to the draft page
"""
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
account = globals.get_or_create_account(user)
league_id = account.league
league = league_key(league_id).get()
league_comissioner = league.key.id()
if league_comissioner == user_id:
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch()
if len(league_players) > 1:
if league.draft_current_position == 0:
start_draft(league_id)
setup_for_next_pick(league_id)
self.redirect('/draft/')
else:
globals.display_error_page(
self, self.request.referer,
error_messages.draft_already_completed)
else:
globals.display_error_page(self, self.request.referer,
error_messages.league_too_small)
else:
globals.display_error_page(self, self.request.referer,
error_messages.access_denied)
def post(self):
user = users.get_current_user()
account = globals.get_or_create_account(user)
commissioner_account_key = account.key
current_league = league_key(
commissioner_account_key.get().league).get()
#Get data from the post header
name = self.request.get('name')
snake = self.request.get('snake_draft') == 'on'
if not current_league or current_league.draft_current_position == 0:
if name != globals.draft_started_sentinel:
#Create/Update the league
new_league = League.get_or_insert(
commissioner_account_key.id())
new_league.name = name
new_league.snake_draft = snake
new_league.draft_current_position = 0
new_league.put()
add_to_league(user.user_id(), new_league.key.id())
self.redirect('/')
else:
globals.display_error_page(
self, self.request.referer,
error_messages.league_already_started_leaving)
def get(self):
# Checks for active Google account session
user = users.get_current_user()
#Check if user is logged in
if user is None:
#Send html data to browser
template_values = {'logged_out': users.create_login_url('/help/points')}
template = JINJA_ENVIRONMENT.get_template('templates/points_detail.html')
self.response.write(template.render(template_values))
else:
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
logging.info(account)
if league_id != '0':
league_name = league_key(league_id).get().name
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name
}
template = JINJA_ENVIRONMENT.get_template('templates/points_detail.html')
self.response.write(template.render(template_values))
def get(self):
"""
When visited by the league commissioner, the draft is started
The commissioner is then redirected to the draft page
"""
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
account = globals.get_or_create_account(user)
league_id = account.league
league = league_key(league_id).get()
league_comissioner = league.key.id()
if league_comissioner == user_id:
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch()
if len(league_players) > 1:
if league.draft_current_position == 0:
start_draft(league_id)
setup_for_next_pick(league_id)
self.redirect('/draft/')
else:
globals.display_error_page(self, self.request.referer, error_messages.draft_already_completed)
else:
globals.display_error_page(self, self.request.referer, error_messages.league_too_small)
else:
globals.display_error_page(self, self.request.referer,error_messages.access_denied)
def close_draft(league_id):
"""
Preform all of the operations necessary to finish the drafting process
:param league_id: The league to do this in
Called at the end of the draft
Initialize lineup items
Generate schedule
"""
league = league_key(league_id).get()
league.draft_current_position = -1 # Indicate the draft is over
league.draft_current_timeout = None
league.put()
#Build a schedule
generate_schedule(league_id)
#Initialize requirements for bench/active system and distribute a schedule
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch()
for player in league_players:
#For the active system
choice = Choice.get_or_insert(league_id, parent=player.key)
for i in range(1, globals.number_of_official_weeks + 1):
initialize_lineup(i, choice) # Initialize weekly lineups
player.record.append('')
player.put()
def get(self):
user_id = users.get_current_user().user_id()
if league_key(account_key(
user_id).get().league).get().draft_current_position == 0:
remove_from_league(user_id)
self.redirect('/')
else:
globals.display_error_page(
self, self.request.referer,
error_messages.league_already_started_leaving)
def delete_league(league_id):
if league_id != '0': #Don't ever delete the default league
league = league_key(league_id).get()
players = Account.query().filter(Account.league == league_id).fetch()
draft_picks = DraftPick.query(ancestor=league.key).fetch()
for player in players:
remove_from_league(player.key.id())
for draft_pick in draft_picks:
draft_pick.key.delete()
league.key.delete()
def get(self, league_id):
user_id = users.get_current_user().user_id()
if league_key(league_id).get().draft_current_position == 0:
remove_from_league(user_id) #Remove from old league
add_to_league(user_id, league_id) #Add to new one
self.redirect('/')
else:
template = JINJA_ENVIRONMENT.get_template('templates/error_page.html')
self.response.write(template.render({'Message':'This league has already begun, or has finished its draft'}))
def get(self, league_id):
"""
Adds a user to the specified league
:param league_id: Collected from url, the league to join
"""
user_id = users.get_current_user().user_id()
current_league = league_key(account_key(user_id).get().league).get()
if not current_league or current_league.draft_current_position == 0:
if league_key(league_id).get().draft_current_position == 0:
remove_from_league(user_id) #Remove from old league
add_to_league(user_id, league_id) #Add to new one
self.redirect('/')
else:
globals.display_error_page(
self, self.request.referer,
error_messages.league_already_started)
else:
globals.display_error_page(
self, self.request.referer,
error_messages.league_already_started_leaving)
def delete_league(league_id):
"""Delete a particular league"""
if league_id != '0': #Don't ever delete the default league
league = league_key(league_id).get()
players = Account.query().filter(Account.league == league_id).fetch()
draft_picks = DraftPick.query(ancestor=league.key).fetch()
for player in players:
remove_from_league(player.key.id())
for draft_pick in draft_picks:
draft_pick.key.delete()
league.key.delete()
def get(self):
# Checks for active Google account session
user = users.get_current_user()
#Check if user is logged in
if user is None:
#Send html data to browser
template_values = {
'logged_out': users.create_login_url('/help/points')
}
template = JINJA_ENVIRONMENT.get_template(
'templates/points_detail.html')
self.response.write(template.render(template_values))
else:
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name
}
template = JINJA_ENVIRONMENT.get_template(
'templates/points_detail.html')
self.response.write(template.render(template_values))
def get(self):
# Checks for active Google account session
user = users.get_current_user()
#Check if user is logged in
if user is None:
#Send html data to browser
template_values = {'logged_out': users.create_login_url('/about')}
template = JINJA_ENVIRONMENT.get_template('templates/about.html')
self.response.write(template.render(template_values))
else:
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
#Make call to global method to id a user
account = globals.get_or_create_account(user)
league_id = account.league
#Proccess the league info
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name
}
template = JINJA_ENVIRONMENT.get_template('templates/about.html')
self.response.write(template.render(template_values))
def post(self):
# Checks for active Google account session
user = users.get_current_user()
account = globals.get_or_create_account(user)
league_id = account.league
league_entity = league_key(league_id).get()
current_position = league_entity.draft_current_position
current_timeout = league_entity.draft_current_timeout
current_time = datetime.datetime.utcnow()
if current_position != 0 and current_position != -1: #Don't process if draft is over or yet to begin
current_pick = draft_pick_key(league_entity.key,
current_position).get()
if current_pick.player == account.key.urlsafe(
): #Check that the calling player is actually within their turn
if current_time < current_timeout: #Check that the calling player is within their time constraints
#Get the new team from the post header
new_team = self.request.get('team')
#Validate the selection
selection_error = is_valid_team(new_team, league_id)
if selection_error == "Good":
#S'all good, update the datastore
current_pick.team = int(new_team)
current_pick.put()
#Add the team to the user's roster
user_choice = Choice.get_or_insert(league_id,
parent=account.key)
if not user_choice.current_team_roster: # Make sure to use [] for an empty roster, not None
user_choice.current_team_roster = []
user_choice.current_team_roster.append(int(new_team))
user_choice.put()
#Move the draft along
setup_for_next_pick(league_id)
else:
selection_error = "The time for your selection has expired"
else:
selection_error = "It is not your turn to make a selection"
else:
selection_error = "Draft is not currently in session"
#Display the draft main page with status
self.redirect('/draft/?updated=' + selection_error)
def setup_for_next_pick(league_id):
"""
Set the database so that the next person can make a selection
:param league_id: League to do this in
If the draft is finished, appropriately call lose_draft
If the draft is still in progress, increase the current draft_position by one and reset the timeout
"""
league = league_key(league_id).get()
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch()
number_of_picks = len(league_players) * globals.draft_rounds
if league.draft_current_position == number_of_picks: # See if the draft is over
close_draft(league_id)
else:
league.draft_current_position += 1
league.draft_current_timeout = datetime.datetime.utcnow() \
+ datetime.timedelta(minutes=globals.draft_time_minutes)
league.put()
def setup_for_next_pick(league_id):
"""
Set the database so that the next person can make a selection
:param league_id: League to do this in
If the draft is finished, appropriately call lose_draft
If the draft is still in progress, increase the current draft_position by one and reset the timeout
"""
league = league_key(league_id).get()
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch()
number_of_picks = len(league_players) * globals.draft_rounds
if league.draft_current_position == number_of_picks: # See if the draft is over
close_draft(league_id)
else:
league.draft_current_position += 1
league.draft_current_timeout = datetime.datetime.utcnow() \
+ datetime.timedelta(minutes=globals.draft_time_minutes)
league.put()
def post(self):
# Checks for active Google account session
user = users.get_current_user()
account = globals.get_or_create_account(user)
league_id = account.league
league_entity = league_key(league_id).get()
current_position = league_entity.draft_current_position
current_timeout = league_entity.draft_current_timeout
current_time = datetime.datetime.utcnow()
if current_position != 0 and current_position != -1: #Don't process if draft is over or yet to begin
current_pick = draft_pick_key(league_entity.key, current_position).get()
if current_pick.player == account.key.urlsafe(): #Check that the calling player is actually within their turn
if current_time < current_timeout: #Check that the calling player is within their time constraints
#Get the new team from the post header
new_team = self.request.get('team')
#Validate the selection
selection_error = is_valid_team(new_team, league_id)
if selection_error == "Good":
#S'all good, update the datastore
current_pick.team = int(new_team)
current_pick.put()
#Add the team to the user's roster
user_choice = Choice.get_or_insert(league_id, parent=account.key)
if not user_choice.current_team_roster: # Make sure to use [] for an empty roster, not None
user_choice.current_team_roster = []
user_choice.current_team_roster.append(int(new_team))
user_choice.put()
#Move the draft along
setup_for_next_pick(league_id)
else:
selection_error = "The time for your selection has expired"
else:
selection_error = "It is not your turn to make a selection"
else:
selection_error = "Draft is not currently in session"
#Display the draft main page with status
self.redirect('/draft/?updated=' + selection_error)
def get(self):
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
league_query = League.query()
league_list = league_query.fetch()
league_output = []
for league in league_list:
number_of_players = len(Account.query().filter(Account.league == league.key.id()).fetch())
commissioner = "None"
if account_key(league.key.id()).get():
commissioner = account_key(league.key.id()).get().nickname
league_output.append({'name': league.name,
'id': league.key.id(),
'size': number_of_players,
'commissioner': commissioner,
'join_url': '/leagueManagement/joinLeague/' + league.key.id()
})
if league_id != '0':
league_name = league_key(league_id).get().name
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_list': league_output,
'league_name': league_name
}
template = JINJA_ENVIRONMENT.get_template('templates/league_list.html')
self.response.write(template.render(template_values))
def get(self, team_number):
"""
Display detailed information on a single team
:param team_number: The team number, gathered from the url, in string form
Includes the following information:
- Schedule: Which events is this team attending. Also gives the points scored (for past events)
- Point breakdown: For each event, a detailed breakdown of where all of their points came
"""
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
team_data = {}
team_data['number'] = team_number
team_data['schedule'] = get_team_schedule(int(team_number))
team_name = "Team " + str(team_number) + " - " + root_team_key(
str(team_number)).get().name
tba_team_url = globals.public_team_url.format(team_number)
event_breakdowns = []
point_breakdown = []
for event in get_team_schedule(int(team_number)):
if event['competition_name'] != '' and event['competition_name']:
event_breakdowns.append(
get_point_breakdown_display(int(team_number),
event['event_key']))
for i, name in enumerate(humman_readable_point_categories):
point_breakdown.append([]) # Create the new row
#Build the data neccessary for the title/tooltip
title = {
'title': name,
'explanation': explanation_of_point_categories[i]
}
point_breakdown[i].append(
title) # Add the tile for the first column
category_total = 0
for event in event_breakdowns:
#Event is a value in the form [cat1,cat2...]
category_total += event[i][
'points'] # Build the total for the end of the row
event_text = ""
if 'tooltip' in event[
i]: # If there's a tooltip, pass it on to the page
point_breakdown[i].append({
'points': event[i]['display'],
'tooltip': event[i]['tooltip']
})
else:
point_breakdown[i].append(
event[i]
['display']) # For each event, add the point display
point_breakdown[i].append(category_total) # Finally, add the total
point_breakdown.append([]) # For totals
index_of_totals_row = len(humman_readable_point_categories)
overall_total = 0
point_breakdown[index_of_totals_row].append(
'Overall Total:') # Left column row title
for event in get_team_schedule(int(team_number)):
if event['competition_name'] != '' and event['competition_name']:
overall_total += event['points']
point_breakdown[index_of_totals_row].append(
"") # For each event, add the total value
point_breakdown[index_of_totals_row].append(
overall_total) # Finally, add the total
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'team_data': team_data,
'team_name': team_name,
'tba_team_url': tba_team_url,
'pointbreakdown': point_breakdown,
}
template = JINJA_ENVIRONMENT.get_template('templates/team_detail.html')
self.response.write(template.render(template_values))
def get(self):
"""
The main dashboard for league + personal info
Contains information on the following:
- The league schedule, including bye weeks and who plays who
- The leader board, showing bench points and league points for each player, ranked
- The current user's lineup for each week, including the points scored for past weeks
- The current user's current roster
"""
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
#Make global call to get user information
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
draft_over = league_key(league_id).get().draft_current_position == -1
#Only allow access to this page after the draft has completed
if draft_over:
#Proccess league info
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
total_points = 0
week_table = []
for weeknum in range(1, globals.number_of_official_weeks + 1):
teams = get_team_lists(user_id, weeknum)[0]
points = 0
lineup = []
for team in teams:
event_key = get_team_schedule(int(team['number']))[int(weeknum) - 1]['event_key']#-1 to convert to 0-based index
if event_key: #Check if the team is competing that week
points += get_team_points_at_event(team['number'], event_key)
lineup.append(team['number'])
if is_week_editable(weeknum):
points = "<i>No Data</i>"
else:
total_points += points
week_row = {'week': str(weeknum), 'active_lineup': lineup, 'points': points}
week_table.append(week_row)
leader_board = get_leader_board(league_id)
league_schedule = get_readable_schedule(league_id)
current_roster = get_current_roster(user_id)
user_schedule = get_readable_user_schedule(user_id)
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'week_table': week_table,
'total_points': total_points,
'leader_board': leader_board,
'schedule': league_schedule,
'roster': current_roster,
'week_number': globals.debug_current_editable_week,
'user_schedule': user_schedule
}
template = JINJA_ENVIRONMENT.get_template('templates/alliance_management_portal.html')
self.response.write(template.render(template_values))
else:
globals.display_error_page(self, self.request.referer, error_messages.draft_needs_to_be_completed)
else:
globals.display_error_page(self, self.request.referer, error_messages.need_to_be_a_member_of_a_league)
def start_draft(league_id):
"""
Set up to prepare for a draft
:parameter league_id: The league to prepare for a draft
Do the following:
- Create a random order
- Use this order to generate a single list of exactly what pick happens in what order
- Use this to create the necessary pick objects with the correct order properties
- Place the league in a position to begin the draft
"""
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch()
shuffle(league_players) # Randomize the order of the draft
number_of_players = len(league_players)
number_of_picks = number_of_players * globals.draft_rounds
snake_draft = league_key(league_id).get().snake_draft
direction = DRAFT_INCREASING
pick_of_round = 0
display_number = 0
number_of_drafts = 0
while number_of_drafts < number_of_picks:
if snake_draft:
if direction == DRAFT_INCREASING:
if pick_of_round == number_of_players:
direction = DRAFT_STATIONARY
elif direction == DRAFT_DECREASING:
if pick_of_round == 1:
direction = DRAFT_STATIONARY
elif direction == DRAFT_STATIONARY:
if pick_of_round == 1:
direction = DRAFT_INCREASING
elif pick_of_round == number_of_players:
direction = DRAFT_DECREASING
else:
if pick_of_round == number_of_players:
pick_of_round = 0 # 0 will become a 1 down below because direction = DRAFT_INCREASING
if direction == DRAFT_INCREASING:
pick_of_round += 1
display_number += 1
elif direction == DRAFT_DECREASING:
pick_of_round -= 1
display_number -= 1
elif direction == DRAFT_STATIONARY:
display_number += 4
player = league_players[pick_of_round - 1]
pick_key = draft_pick_key(league_key(league_id),
str(number_of_drafts + 1))
pick = DraftPick.get_or_insert(pick_key.id(), parent=pick_key.parent())
pick.display_number = display_number
pick.player = player.key.urlsafe()
pick.put()
number_of_drafts += 1
league = league_key(league_id).get()
league.draft_current_position = 0
league.put()
def get(self, week_number):
"""
Handle the requests to see data for all alliances. Displays a past_alliance or alliance_management tab appropriately.
:parameter week_number: Week number taken from the url, string form
For each team on the bench and active lineup: displays information about each team's past performance
Also displays opponent's active and bench lineup
"""
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
draft_over = league_key(league_id).get().draft_current_position == -1
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
if draft_over:
team_lists = get_team_lists(user_id, week_number)
point_totals = []
for team_list in team_lists:
point_total = 0
for team in team_list:
point_total += team['total_points']
point_totals.append(point_total)
opponent_name = ""
opponent_point_totals = []
opponent_team_lists = []
team_listss = [team_lists]
if get_opponent(user_id, week_number) != globals.schedule_bye_week:
opponent_team_lists = get_team_lists(get_opponent(user_id, week_number), week_number)
opponent_point_totals = []
for team_list in team_lists:
opponent_point_total = 0
for team in team_list:
opponent_point_total += team['total_points']
opponent_point_totals.append(opponent_point_total)
opponent_name = get_opponent_name(user_id, week_number)
team_listss.append(opponent_team_lists)
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'week_number': int(week_number),
'point_totals': [point_totals, opponent_point_totals],
'team_listss': team_listss,
'opponent_name': opponent_name,
}
if is_week_editable(week_number):
template = JINJA_ENVIRONMENT.get_template('templates/alliance_management.html')
else:
template = JINJA_ENVIRONMENT.get_template('templates/past_alliances.html')
self.response.write(template.render(template_values))
else:
globals.display_error_page(self, self.request.referer, error_messages.draft_needs_to_be_completed)
def get(self):
"""
The draft page contains the draft board, a timer, and a map; all that is necessary for the draft process
"""
# Checks for active Google account session
user = users.get_current_user()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
#Make check to see if the time for the current pick has expired
current_time = datetime.datetime.utcnow()
current_timeout = league_key(league_id).get().draft_current_timeout
draft_pick = draft_pick_key(
league_key(league_id),
league_key(league_id).get().draft_current_position).get()
if current_timeout:
if current_time > current_timeout: # The time has expired
draft_pick.team = 0 # Set the pick to indicate it was forefited
draft_pick.put()
setup_for_next_pick(
league_id) # Move the pick along to the next person
#Display update text for the status of the last choice update
update_text = self.request.get('updated')
if self.request.get('updated') == "Good":
update_text = "Team added successfully"
league_player_query = Account.query(Account.league == league_id)
players_for_the_sake_of_number = league_player_query.fetch()
league_players = []
if draft_pick_key(league_key(league_id), 1).get(): # != None
for i in range(1, len(players_for_the_sake_of_number) + 1):
pick = draft_pick_key(league_key(league_id), i).get()
league_players.append(ndb.Key(urlsafe=pick.player).get())
else:
league_players = players_for_the_sake_of_number
draft_board = []
player_list = []
for player in league_players:
player_list.append(player.nickname)
number_of_picks = len(league_players) * globals.draft_rounds
for position in range(1, number_of_picks + 1):
pick_query = DraftPick.query().filter(
DraftPick.display_number == position)
query_results = pick_query.fetch(1)
pick = DraftPick()
if len(query_results) != 0:
pick = query_results[0]
username = (((position % len(league_players)) - 1) %
len(league_players))
draft_round = int((position - 1) / len(league_players))
if username == 0:
draft_board.append([])
for i in range(0, len(league_players)):
draft_board[draft_round].append('-')
if pick and pick.team != None:
draft_board[draft_round][username] = str(pick.team)
if pick.team == 0:
draft_board[draft_round][username] = "<i>Forfeited</i>"
else:
draft_board[draft_round][username] = "<i>TBD</i>"
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
users_turn = False
picking_user = ""
draft_pick = draft_pick_key(
league_key(league_id),
league_key(league_id).get().draft_current_position).get()
if draft_pick:
users_turn = (draft_pick.player == account.key.urlsafe())
picking_user = ndb.Key(
urlsafe=draft_pick.player).get().nickname
current_unix_timeout = None
if current_timeout:
current_unix_timeout = calendar.timegm(
current_timeout.timetuple())
current_position = league_key(
league_id).get().draft_current_position
if current_position == 0:
draft_status = "Pre"
elif current_position == -1:
draft_status = "Post"
else:
draft_status = "Mid"
team_map_data = get_lat_lng_json(league_id)
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'draft_board': draft_board,
'player_list': player_list,
'update_text': update_text,
'league_name': league_name,
'users_turn': users_turn,
'picking_user': picking_user,
'current_unix_timeout': current_unix_timeout,
'draft_status': draft_status,
'team_map_data': team_map_data,
}
template = JINJA_ENVIRONMENT.get_template(
'templates/draft_main.html')
self.response.write(template.render(template_values))
else:
globals.display_error_page(
self, self.request.referer,
error_messages.need_to_be_a_member_of_a_league)
def get(self):
# Checks for active Google account session
user = users.get_current_user()
#Force user login
if user is None:
self.redirect(users.create_login_url(self.request.uri))
else:
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
#Get user's choices for the current league
find_choice_key = choice_key(account_key(user_id), str(league_id))
found_choice = find_choice_key.get()
#Display update text for the status of the last choice update
update_text = self.request.get('updated')
if self.request.get('updated') == "Good":
update_text = "Team added successfully"
#Display the user's current roster
user_roster = []
if found_choice:
user_roster = found_choice.current_team_roster
#Get list of players in the league and their choices
league_table = [{'player_team': 'Roster', 'player_name': 'Player'}]
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch() #league_player_query.order(Account.nickname).fetch()
for player in league_players:
choice = choice_key(account_key(player.key.id()), league_id).get()
if choice:
league_table.append(
{'player_team': str(choice.current_team_roster), 'player_name': player.nickname})
else:
league_table.append({'player_team': 'None', 'player_name': player.nickname})
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'update_text': update_text,
'league_table': league_table,
'league_name': league_name,
'roster': user_roster,
'default_team': self.request.get('team'),
}
template = JINJA_ENVIRONMENT.get_template('templates/pick_up_main.html')
self.response.write(template.render(template_values))
def get(self, week_number):
"""
Handle the requests to see data for all alliances. Displays a past_alliance or alliance_management tab appropriately.
:parameter week_number: Week number taken from the url, string form
For each team on the bench and active lineup: displays information about each team's past performance
Also displays opponent's active and bench lineup
"""
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
draft_over = league_key(league_id).get().draft_current_position == -1
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
if draft_over:
team_lists = get_team_lists(user_id, week_number)
point_totals = []
for team_list in team_lists:
point_total = 0
for team in team_list:
point_total += team['total_points']
point_totals.append(point_total)
opponent_name = ""
opponent_point_totals = []
opponent_team_lists = []
team_listss = [team_lists]
if get_opponent(user_id, week_number) != globals.schedule_bye_week:
opponent_team_lists = get_team_lists(
get_opponent(user_id, week_number), week_number)
opponent_point_totals = []
for team_list in team_lists:
opponent_point_total = 0
for team in team_list:
opponent_point_total += team['total_points']
opponent_point_totals.append(opponent_point_total)
opponent_name = get_opponent_name(user_id, week_number)
team_listss.append(opponent_team_lists)
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'week_number': int(week_number),
'point_totals': [point_totals, opponent_point_totals],
'team_listss': team_listss,
'opponent_name': opponent_name,
}
if is_week_editable(week_number):
template = JINJA_ENVIRONMENT.get_template(
'templates/alliance_management.html')
else:
template = JINJA_ENVIRONMENT.get_template(
'templates/past_alliances.html')
self.response.write(template.render(template_values))
else:
globals.display_error_page(
self, self.request.referer,
error_messages.draft_needs_to_be_completed)
def get(self):
"""
The draft page contains the draft board, a timer, and a map; all that is necessary for the draft process
"""
# Checks for active Google account session
user = users.get_current_user()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
#Make check to see if the time for the current pick has expired
current_time = datetime.datetime.utcnow()
current_timeout = league_key(league_id).get().draft_current_timeout
draft_pick = draft_pick_key(league_key(league_id), league_key(league_id).get().draft_current_position).get()
if current_timeout:
if current_time > current_timeout: # The time has expired
draft_pick.team = 0 # Set the pick to indicate it was forefited
draft_pick.put()
setup_for_next_pick(league_id) # Move the pick along to the next person
#Display update text for the status of the last choice update
update_text = self.request.get('updated')
if self.request.get('updated') == "Good":
update_text = "Team added successfully"
league_player_query = Account.query(Account.league == league_id)
players_for_the_sake_of_number = league_player_query.fetch()
league_players = []
if draft_pick_key(league_key(league_id), 1).get(): # != None
for i in range(1, len(players_for_the_sake_of_number) + 1):
pick = draft_pick_key(league_key(league_id), i).get()
league_players.append(ndb.Key(urlsafe=pick.player).get())
else:
league_players = players_for_the_sake_of_number
draft_board = []
player_list = []
for player in league_players:
player_list.append(player.nickname)
number_of_picks = len(league_players) * globals.draft_rounds
for position in range(1, number_of_picks + 1):
pick_query = DraftPick.query().filter(DraftPick.display_number == position)
query_results = pick_query.fetch(1)
pick = DraftPick()
if len(query_results) != 0:
pick = query_results[0]
username = (((position % len(league_players)) - 1) % len(league_players))
draft_round = int((position - 1) / len(league_players))
if username == 0:
draft_board.append([])
for i in range(0, len(league_players)):
draft_board[draft_round].append('-')
if pick and pick.team != None:
draft_board[draft_round][username] = str(pick.team)
if pick.team == 0:
draft_board[draft_round][username] = "<i>Forfeited</i>"
else:
draft_board[draft_round][username] = "<i>TBD</i>"
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
users_turn = False
picking_user = ""
draft_pick = draft_pick_key(league_key(league_id), league_key(league_id).get().draft_current_position).get()
if draft_pick:
users_turn = (draft_pick.player == account.key.urlsafe())
picking_user = ndb.Key(urlsafe=draft_pick.player).get().nickname
current_unix_timeout = None
if current_timeout:
current_unix_timeout = calendar.timegm(current_timeout.timetuple())
current_position = league_key(league_id).get().draft_current_position
if current_position == 0:
draft_status = "Pre"
elif current_position == -1:
draft_status = "Post"
else:
draft_status = "Mid"
team_map_data = get_lat_lng_json(league_id)
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'draft_board': draft_board,
'player_list': player_list,
'update_text': update_text,
'league_name': league_name,
'users_turn': users_turn,
'picking_user': picking_user,
'current_unix_timeout': current_unix_timeout,
'draft_status': draft_status,
'team_map_data': team_map_data,
}
template = JINJA_ENVIRONMENT.get_template('templates/draft_main.html')
self.response.write(template.render(template_values))
else:
globals.display_error_page(self, self.request.referer,error_messages.need_to_be_a_member_of_a_league)
def start_draft(league_id):
"""
Set up to prepare for a draft
:parameter league_id: The league to prepare for a draft
Do the following:
- Create a random order
- Use this order to generate a single list of exactly what pick happens in what order
- Use this to create the necessary pick objects with the correct order properties
- Place the league in a position to begin the draft
"""
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch()
shuffle(league_players) # Randomize the order of the draft
number_of_players = len(league_players)
number_of_picks = number_of_players * globals.draft_rounds
snake_draft = league_key(league_id).get().snake_draft
direction = DRAFT_INCREASING
pick_of_round = 0
display_number = 0
number_of_drafts = 0
while number_of_drafts < number_of_picks:
if snake_draft:
if direction == DRAFT_INCREASING:
if pick_of_round == number_of_players:
direction = DRAFT_STATIONARY
elif direction == DRAFT_DECREASING:
if pick_of_round == 1:
direction = DRAFT_STATIONARY
elif direction == DRAFT_STATIONARY:
if pick_of_round == 1:
direction = DRAFT_INCREASING
elif pick_of_round == number_of_players:
direction = DRAFT_DECREASING
else:
if pick_of_round == number_of_players:
pick_of_round = 0 # 0 will become a 1 down below because direction = DRAFT_INCREASING
if direction == DRAFT_INCREASING:
pick_of_round += 1
display_number += 1
elif direction == DRAFT_DECREASING:
pick_of_round -= 1
display_number -= 1
elif direction == DRAFT_STATIONARY:
display_number += 4
player = league_players[pick_of_round - 1]
pick_key = draft_pick_key(league_key(league_id), str(number_of_drafts + 1))
pick = DraftPick.get_or_insert(pick_key.id(), parent=pick_key.parent())
pick.display_number = display_number
pick.player = player.key.urlsafe()
pick.put()
number_of_drafts += 1
league = league_key(league_id).get()
league.draft_current_position = 0
league.put()
def get(self):
# Checks for active Google account session
user = users.get_current_user()
#Force user login
if user is None:
self.redirect(users.create_login_url(self.request.uri))
else:
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
#Get user's choices for the current league
find_choice_key = choice_key(account_key(user_id), str(league_id))
found_choice = find_choice_key.get()
#Display update text for the status of the last choice update
update_text = self.request.get('updated')
if self.request.get('updated') == "Good":
update_text = "Team added successfully"
#Display the user's current roster
user_roster = []
if found_choice:
user_roster = found_choice.current_team_roster
#Get list of players in the league and their choices
league_table = [{'player_team': 'Roster', 'player_name': 'Player'}]
league_player_query = Account.query(Account.league == league_id)
league_players = league_player_query.fetch(
) #league_player_query.order(Account.nickname).fetch()
for player in league_players:
choice = choice_key(account_key(player.key.id()),
league_id).get()
if choice:
league_table.append({
'player_team':
str(choice.current_team_roster),
'player_name':
player.nickname
})
else:
league_table.append({
'player_team': 'None',
'player_name': player.nickname
})
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'update_text': update_text,
'league_table': league_table,
'league_name': league_name,
'roster': user_roster,
'default_team': self.request.get('team'),
}
template = JINJA_ENVIRONMENT.get_template(
'templates/pick_up_main.html')
self.response.write(template.render(template_values))
def get(self, team_number):
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
league_name = league_key(league_id).get().name
else:
league_name = ""
team_data = {}
team_data['number'] = team_number
team_data['schedule'] = get_team_schedule(int(team_number))
team_name = "Team " + str(team_number) + " - " + root_team_key(str(team_number)).get().name
tba_team_url = globals.public_team_url % team_number
event_breakdowns = []
point_breakdown = []
for event in get_team_schedule(int(team_number)):
if event['competition_name'] != '' and event['competition_name']:
event_breakdowns.append(get_point_breakdown_display(int(team_number), event['event_key']))
for i, name in enumerate(humman_readable_point_categories):
point_breakdown.append([]) #Create the new row
title = {'title':name, 'explanation': explanation_of_point_categories[i]} #Build the data neccessary for the title/tooltip
point_breakdown[i].append(title) #Add the tile for the first column
category_total = 0
for event in event_breakdowns:
#Event is a value in the form [cat1,cat2...]
category_total += event[i]['points'] #Build the total for the end of the row
event_text = ""
if 'tooltip' in event[i]: #If there's a tooltip, pass it on to the page
point_breakdown[i].append({'points': event[i]['display'], 'tooltip': event[i]['tooltip']})
else:
point_breakdown[i].append(event[i]['display']) #For each event, add the point display
point_breakdown[i].append(category_total) #Finally, add the total
point_breakdown.append([]) #For totals
index_of_totals_row = len(humman_readable_point_categories)
overall_total = 0
point_breakdown[index_of_totals_row].append('Overall Total:') #Left column row title
for event in get_team_schedule(int(team_number)):
if event['competition_name'] != '' and event['competition_name']:
overall_total += event['points']
point_breakdown[index_of_totals_row].append("") #For each event, add the total value
point_breakdown[index_of_totals_row].append(overall_total) #Finally, add the total
#Send html data to browser
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'team_data': team_data,
'team_name': team_name,
'tba_team_url': tba_team_url,
'pointbreakdown': point_breakdown,
}
template = JINJA_ENVIRONMENT.get_template('templates/team_detail.html')
self.response.write(template.render(template_values))
def get(self):
"""
The main dashboard for league + personal info
Contains information on the following:
- The league schedule, including bye weeks and who plays who
- The leader board, showing bench points and league points for each player, ranked
- The current user's lineup for each week, including the points scored for past weeks
- The current user's current roster
"""
# Checks for active Google account session
user = users.get_current_user()
#Current user's id, used to identify their data
user_id = user.user_id()
logout_url = users.create_logout_url('/')
#Make global call to get user information
account = globals.get_or_create_account(user)
league_id = account.league
if league_id != '0':
draft_over = league_key(
league_id).get().draft_current_position == -1
#Only allow access to this page after the draft has completed
if draft_over:
#Proccess league info
if league_id != '0':
if league_key(league_id).get().draft_current_position == 0:
league_name = league_key(league_id).get().name
else:
league_name = globals.draft_started_sentinel
else:
league_name = ""
total_points = 0
week_table = []
for weeknum in range(1, globals.number_of_official_weeks + 1):
teams = get_team_lists(user_id, weeknum)[0]
points = 0
lineup = []
for team in teams:
event_key = get_team_schedule(int(
team['number']))[int(weeknum) - 1][
'event_key'] #-1 to convert to 0-based index
if event_key: #Check if the team is competing that week
points += get_team_points_at_event(
team['number'], event_key)
lineup.append(team['number'])
if is_week_editable(weeknum):
points = "<i>No Data</i>"
else:
total_points += points
week_row = {
'week': str(weeknum),
'active_lineup': lineup,
'points': points
}
week_table.append(week_row)
leader_board = get_leader_board(league_id)
league_schedule = get_readable_schedule(league_id)
current_roster = get_current_roster(user_id)
user_schedule = get_readable_user_schedule(user_id)
template_values = {
'user': user.nickname(),
'logout_url': logout_url,
'league_name': league_name,
'week_table': week_table,
'total_points': total_points,
'leader_board': leader_board,
'schedule': league_schedule,
'roster': current_roster,
'week_number': globals.debug_current_editable_week,
'user_schedule': user_schedule
}
template = JINJA_ENVIRONMENT.get_template(
'templates/alliance_management_portal.html')
self.response.write(template.render(template_values))
else:
globals.display_error_page(
self, self.request.referer,
error_messages.draft_needs_to_be_completed)
else:
globals.display_error_page(
self, self.request.referer,
error_messages.need_to_be_a_member_of_a_league)