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)