def post(self):
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
find_Choice_key = choice_key(account_key(user_id), str(league_id))
post_Choice_key = find_Choice_key
new_team = self.request.get('team')
selection_error = is_valid_team(new_team,
post_Choice_key.parent().get().league)
#Form data into entity and submit
post_Choice = Choice.get_or_insert(post_Choice_key.id(),
parent=post_Choice_key.parent())
if selection_error == "Good":
if len(
choice_key(account_key(user_id), league_id).get().
current_team_roster) < maximum_roster_size:
post_Choice.current_team_roster.append(int(new_team))
str(post_Choice.put())
else:
selection_error = "You have reached the maximum capacity for teams on your roster"
# close_draft(post_Choice_key.parent().get().league)
#Display the homepage
self.redirect('/draft/pickUp/?updated=' + selection_error)
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 get(self):
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
find_Choice_key = choice_key(account_key(user_id), str(league_id))
post_Choice_key = find_Choice_key
new_team = self.request.get('team')
selection_error = is_valid_team(new_team,
post_Choice_key.parent().get().league)
#Form data into entity and submit
post_Choice = Choice.get_or_insert(post_Choice_key.id(),
parent=post_Choice_key.parent())
if selection_error == "Good":
if len(
choice_key(account_key(user_id), league_id).get().
current_team_roster) < maximum_roster_size:
post_Choice.current_team_roster.append(int(new_team))
str(post_Choice.put())
else:
selection_error = "Your roster is full"
#Send them back to the previous page
self.redirect(
str(
self.request.referer.split('?', 1)[0] + '?updated=' +
selection_error))
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 get(self):
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
find_Choice_key = choice_key(account_key(user_id), str(league_id))
post_Choice_key = find_Choice_key
new_team = self.request.get('team')
selection_error = is_valid_team(new_team, post_Choice_key.parent().get().league)
#Form data into entity and submit
post_Choice = Choice.get_or_insert(post_Choice_key.id(), parent=post_Choice_key.parent())
if selection_error == "Good":
if len(choice_key(account_key(user_id), league_id).get().current_team_roster) < maximum_roster_size:
post_Choice.current_team_roster.append(int(new_team))
str(post_Choice.put())
else:
selection_error = "Your roster is full"
#Send them back to the previous page
self.redirect(str(self.request.referer.split('?', 1)[0] + '?updated=' + selection_error))
def get(self):
user = users.get_current_user()
account = globals.get_or_create_account(user)
match_key_id = account.active_match
match = ndb.Key(urlsafe=match_key_id).get()
pair = match.key.parent().get()
match.active = False
if match.won != True:
match.won = False
match.put()
pair.current_match_number += 1
pair.put()
account.active_match = globals.no_match_active_id
account.put()
if pair.key.id() == account.key.id():
partner = account_key(pair.key.parent().id()).get()
else:
partner = account_key(pair.key.id()).get()
partner.active_match = globals.no_match_active_id
partner.put()
self.redirect('/')
def post(self):
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
find_Choice_key = choice_key(account_key(user_id), str(league_id))
post_Choice_key = find_Choice_key
new_team = self.request.get('team')
selection_error = is_valid_team(new_team, post_Choice_key.parent().get().league)
#Form data into entity and submit
post_Choice = Choice.get_or_insert(post_Choice_key.id(), parent=post_Choice_key.parent())
if selection_error == "Good":
if len(choice_key(account_key(user_id), league_id).get().current_team_roster) < maximum_roster_size:
post_Choice.current_team_roster.append(int(new_team))
str(post_Choice.put())
else:
selection_error = "You have reached the maximum capacity for teams on your roster"
# close_draft(post_Choice_key.parent().get().league)
#Display the homepage
self.redirect('/draft/pickUp/?updated=' + selection_error)
def post(self):
"""Handles incoming form data"""
user = users.get_current_user()
account = globals.get_or_create_account(user)
word = self.request.get('word')
match_key_id = self.request.get('match_key')
match = ndb.Key(urlsafe=match_key_id).get()
if match.active and not match.won:
user_is_host = match.key.parent().parent().id() == account.key.id()
if user_is_host:
user_word_list = match.user_1_list
partner_word_list = match.user_2_list
else:
user_word_list = match.user_2_list
partner_word_list = match.user_1_list
if len(user_word_list) <= len(partner_word_list):
user_word_list.append(word)
if len(user_word_list) == len(partner_word_list):
if str.lower(str(user_word_list[-1])) == str.lower(str(partner_word_list[-1])):
match.active = False
match.won = True
match.put()
self.redirect('/')
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:
#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 = ""
#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 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, week_number):
"""Updates the active teams for the user"""
#The choice_key of the request
action = self.request.get('action')
team_number = self.request.get('team_number')
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
if is_week_editable(week_number):
active_lineup = lineup_key(Choice_key(account.key, league_id), week_number).get()
if action == "bench":
active_lineup.active_teams.remove(int(team_number))
elif action == "putin":
active_lineup.active_teams.append(int(team_number))
elif action == "drop":
choice = Choice_key(account.key, league_id).get()
choice.current_team_roster.remove(int(team_number))
if int(team_number) in active_lineup.active_teams:
active_lineup.active_teams.remove(int(team_number))
choice.put()
active_lineup.put()
self.redirect('/allianceManagement/viewAlliance/' + str(week_number))
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, week_number):
"""
Update the active teams for the user and redirects them to /viewAlliance/ for the week number
Expects a post parameter: 'action' to be one of the following:
- bench: Takes a team off the active lineup
- putin: Adds a team to the lineup
- drop: Drops a team from the user's roster
Expects a post parameter: 'team_number' to be the number of the team to perform this action on
:parameter week_number: Taken from the url, in string form
"""
#The choice_key of the request
action = self.request.get('action')
team_number = self.request.get('team_number')
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
choice = choice_key(account_key(user_id), league_id).get()
roster = []
for team in choice.current_team_roster:
roster.append(int(team))
#Only allow changes to the lineup if the week is editable
if is_week_editable(week_number):
error = False
active_lineup = lineup_key(choice_key(account.key, league_id),
week_number).get()
if action == "bench":
active_lineup.active_teams.remove(int(team_number))
elif action == "putin":
if len(active_lineup.active_teams) < maximum_active_teams:
if int(team_number) in roster:
active_lineup.active_teams.append(int(team_number))
else:
error = True
else:
error = True
globals.display_error_page(
self, self.request.referer,
error_messages.maximum_active_teams_reached)
elif action == "drop":
if not str(team_number) in get_top_teams(
globals.number_of_locked_teams):
choice = choice_key(account.key, league_id).get()
choice.current_team_roster.remove(int(team_number))
if int(team_number) in active_lineup.active_teams:
active_lineup.active_teams.remove(int(team_number))
choice.put()
active_lineup.put()
if not error:
self.redirect(self.request.referer)
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, week_number):
"""
Update the active teams for the user and redirects them to /viewAlliance/ for the week number
Expects a post parameter: 'action' to be one of the following:
- bench: Takes a team off the active lineup
- putin: Adds a team to the lineup
- drop: Drops a team from the user's roster
Expects a post parameter: 'team_number' to be the number of the team to perform this action on
:parameter week_number: Taken from the url, in string form
"""
#The choice_key of the request
action = self.request.get('action')
team_number = self.request.get('team_number')
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
choice = choice_key(account_key(user_id), league_id).get()
roster = []
for team in choice.current_team_roster:
roster.append(int(team))
#Only allow changes to the lineup if the week is editable
if is_week_editable(week_number):
error = False
active_lineup = lineup_key(choice_key(account.key, league_id), week_number).get()
if action == "bench":
active_lineup.active_teams.remove(int(team_number))
elif action == "putin":
if len(active_lineup.active_teams) < maximum_active_teams:
if int(team_number) in roster:
active_lineup.active_teams.append(int(team_number))
else:
error = True
else:
error = True
globals.display_error_page(self, self.request.referer, error_messages.maximum_active_teams_reached)
elif action == "drop":
if not str(team_number) in get_top_teams(globals.number_of_locked_teams):
choice = choice_key(account.key, league_id).get()
choice.current_team_roster.remove(int(team_number))
if int(team_number) in active_lineup.active_teams:
active_lineup.active_teams.remove(int(team_number))
choice.put()
active_lineup.put()
if not error:
self.redirect(self.request.referer)
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, 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 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 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 post(self):
user = users.get_current_user()
account = globals.get_or_create_account(user)
commissioner_account_key = account.key
#Get data from the post header
name = self.request.get('name')
#Create/Update the league
new_league = League.get_or_insert(commissioner_account_key.id())
new_league.name = name
new_league.draft_current_position = 0
new_league.put()
add_to_league(user.user_id(), new_league.key.id())
self.redirect('/')
def post(self):
user = users.get_current_user()
account = globals.get_or_create_account(user)
match_key_id = self.request.get('match_key')
match = ndb.Key(urlsafe=match_key_id).get()
pair = match.key.parent().get()
match.active = False
if match.won != True:
match.won = False
match.put()
pair.current_match_number += 1
pair.put()
globals.onto_next_match(account, match)
self.redirect('/')
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):
# 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 post(self):
"""Handles the start of a partner connection"""
user = users.get_current_user()
account = globals.get_or_create_account(user)
partner_name = self.request.get('partner_nickname')
partner_name = partner_name.replace("@gmail.com", "")
partner = Account.query(Account.nickname == partner_name).fetch()
if partner:
if partner[0].active_match == globals.no_match_active_id:
pair_key_val = pair_key(account.key.id(), partner[0].key.id())
pair = Pair.get_or_insert(pair_key_val.id(), parent=pair_key_val.parent(), current_match_number=-1)
pair.put()
match_key_val = match_key(pair.current_match_number + 1, pair_key_val)
partner[0].active_match = match_key_val.urlsafe()
partner[0].put()
account.active_match = match_key_val.urlsafe()
account.put()
match = Match.get_or_insert(match_key_val.id(), parent=match_key_val.parent())
match.put()
past_match = Match.get_or_insert(str(pair.current_match_number), parent=pair_key_val)
globals.onto_next_match(account, past_match)
self.redirect('/')
else:
self.redirect("/?updated=User in Game Already")
else:
self.redirect("/?updated=Bad Email Address")
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):
# 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)
match_key_id = account.active_match
user_wordlist = None
partner_wordlist = None
match_won = None
winning_word = None
partner_name = None
users_turn = None
if match_key_id == globals.no_match_active_id:
match_active = False
else:
match_active = True
match = ndb.Key(urlsafe=match_key_id).get()
match_won = match.won
if match.key.parent().parent().id() == account.key.id():
user_wordlist = match.user_1_list
partner_wordlist = match.user_2_list
partner_name = account_key(match.key.parent().id()).get().nickname
else:
partner_wordlist = match.user_1_list
user_wordlist = match.user_2_list
partner_name = account_key(match.key.parent().parent().id()).get().nickname
if len(user_wordlist) != len(partner_wordlist):
if len(user_wordlist) > len(partner_wordlist):
partner_wordlist.append("Waiting...")
users_turn = False
else:
users_turn = True
partner_wordlist[-1] = "*******"
user_wordlist.append("-")
else:
users_turn = True
if match_won:
winning_word = user_wordlist[-1]
user_wordlist = reversed(user_wordlist)
partner_wordlist = reversed(partner_wordlist)
update_text = self.request.get('updated')
#Send html data to browser
template_values = {'user': user.nickname(),
'users_turn': users_turn,
'logout_url': logout_url,
'match_key': match_key_id,
'match_active': match_active,
'match_won': match_won,
'update_text': update_text,
'user_wordlist': user_wordlist,
'partner_wordlist': partner_wordlist,
'partner_name': partner_name,
'winning_word': winning_word,
}
template = JINJA_ENVIRONMENT.get_template('templates/index.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 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, 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):
# 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):
# 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):
"""
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, 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)
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)
