def __show_week_results(self): # show week results once the pool has started d = Database() pool_state = d.get_pool_state(self.year) if pool_state == "invalid" or pool_state == "not_started": return False return True
def __calculate_player_results(self): database = Database() self.__week_data = database.load_week_data(self.year,self.week_number) self.__calc = CalculateResults(self.__week_data) assert self.player_id in self.__week_data.players,"Bad player id" self.__player = self.__week_data.players[self.player_id] self.__calculate_player_summary() self.__calculate_player_game_results_sorted_by_game_number()
def __setup_data_to_use(self, year, week_number, week_data_supplied=None): if week_data_supplied != None: week_data = week_data_supplied else: database = Database() week_data = database.load_week_data(year, week_number) calc = CalculateResults(week_data) self.__players = week_data.players # save to lookup player by id data = WeekWinnerCalculationData() data.player_wins = dict() data.player_projected_wins = dict() data.player_featured_game_picks = dict() data.player_submit_times = dict() data.week_state = calc.get_summary_state_of_all_games() data.featured_game = calc.get_featured_game() data.week = week_data.week if data.featured_game.game_state == NOT_STARTED: data.featured_game_winner = None data.featured_game_ahead = None if data.featured_game.game_state == IN_PROGRESS: data.featured_game_winner = None data.featured_game_ahead = calc.get_team_winning_pool_game( data.featured_game) if data.featured_game.game_state == FINAL: data.featured_game_winner = calc.get_pool_game_winner( data.featured_game) data.featured_game_ahead = None for player_id in week_data.players: player = week_data.players[player_id] data.player_wins[player_id] = calc.get_number_of_wins(player) data.player_projected_wins[ player_id] = calc.get_number_of_projected_wins(player) if calc.player_did_not_pick(player, data.featured_game): data.player_featured_game_picks[player_id] = None data.player_submit_times[player_id] = None else: data.player_featured_game_picks[ player_id] = calc.get_player_pick_for_game( player, data.featured_game) data.player_submit_times[ player_id] = calc.get_player_submit_time( player, data.week) return data
def __calculate_parameters(self): params = dict() params['year'] = self.year params['week_number'] = self.week_number params['weeks_in_year'] = Database().get_week_numbers(self.year) params['navbar_pages'] = self.__get_page_links() self.params = params
def __show_enter_picks(self): user_not_linked_to_player = self.player_id == None if user_not_linked_to_player: return False d = Database() pool_state = d.get_pool_state(self.year) if pool_state == "invalid" or pool_state == "not_started" or pool_state == "week_setup": return False week_state = Database().get_week_state(self.year, self.week_number) if week_state == NOT_STARTED: return True # enter picks page link still shows up if pick deadline has expired # this is so that the user can know that the deadline has expired return False
def test_check_overall_results_weekfinal_page(self): self.utils.overall_results_page(2013) db = Database() self.assertEqual(db.get_pool_state(2013), 'week_final') soup = BeautifulSoup(self.browser.page_source, 'lxml') tags = soup.find_all(id='weekfinal-pool-state') self.assertEqual(len(tags), 1) self.assertEqual(tags[0].text, 'week 2 final') all_ids_counter = Counter( [elem.get('id') for elem in soup.find_all(id=True)]) duplicate_ids = [ id for id in all_ids_counter if all_ids_counter[id] > 1 ] self.longMessage = True self.assertEqual( duplicate_ids, [], 'The following id attributes are duplicate: \n%s' % '\n'.join( ['%s: %d' % (id, all_ids_counter[id]) for id in duplicate_ids])) self.test_db.delete_database()
def __show_update_games(self): d = Database() if self.user.is_superuser: return True user_not_linked_to_player = self.player_id == None if user_not_linked_to_player: return False if d.before_pick_deadline(self.year, self.week_number): return False if d.is_week_scores_locked(self.year, self.week_number): return False if d.is_week_being_setup(self.year, self.week_number): return False return True
def test_check_overall_results_enterpicks_page(self): self.test_db.setup_week_not_started(2013, 3) self.utils.set_pick_deadline_not_expired(2013, 3) self.utils.unlock_picks(2013, 3) self.utils.overall_results_page(2013) db = Database() self.assertEqual(db.get_pool_state(2013), 'enter_picks') soup = BeautifulSoup(self.browser.page_source, 'lxml') tags = soup.find_all(id='enterpicks-pool-state') self.assertEqual(len(tags), 1) self.assertEqual(tags[0].text, 'currently entering picks for week 3') all_ids_counter = Counter( [elem.get('id') for elem in soup.find_all(id=True)]) duplicate_ids = [ id for id in all_ids_counter if all_ids_counter[id] > 1 ] self.longMessage = True self.assertEqual( duplicate_ids, [], 'The following id attributes are duplicate: \n%s' % '\n'.join( ['%s: %d' % (id, all_ids_counter[id]) for id in duplicate_ids])) self.test_db.delete_database()
def __hide_player_results(self, user_access, player_id, year, week_number): show_results = False hide_results = True # always show results if logged in user matches player if user_access.is_player(player_id): return show_results # otherwise, only show other player's results # after pick deadline or if deadline is not set if Database().before_pick_deadline(year, week_number): return hide_results else: return show_results
def load_week_data(year,week_number): d = Database() data = d.load_week_data(year,week_number) return data
def __get_pool_state(self,year): d = Database() pool_state = d.get_pool_state(year) return pool_state
def is_player_in_year(self, year): if self.__player == None: return False players_in_year = Database().load_players(year) return self.__player.id in players_in_year
def setUp(self): self.db = Database()
class LoadWeekDataTest(TestCase): @classmethod def setUpClass(cls): test_db = UnitTestDatabase() test_db.setup_simple_week(2014,1) test_db.load_historical_data_for_year(2013) super(LoadWeekDataTest, cls).setUpClass() @classmethod def tearDownClass(cls): test_db = UnitTestDatabase() test_db.delete_database() super(LoadWeekDataTest, cls).tearDownClass() def setUp(self): self.db = Database() # call the load_week_data function def test_function_call(self): data = self.db.load_week_data(2014,1) self.assertIsNotNone(data) # invalid year parameter def test_bad_year_parameter(self): with self.assertRaises(Exception): data = self.db.load_week_data(1978,1) # invalid week parameter def test_bad_week_parameter(self): with self.assertRaises(Exception): data = self.db.load_week_data(2014,15) # load the week information def test_week_data_present(self): week = self.db.load_week_data(2014,1).week self.assertEqual(week.year.yearnum,2014) self.assertEqual(week.weeknum,1) # load the games indexed by game number information def test_week_games_data_present(self): data = self.db.load_week_data(2014,1) self.assertEqual(len(data.games),10) self.assertEqual(set(data.games.keys()),set([1,2,3,4,5,6,7,8,9,10])) for game in data.games.values(): self.assertEqual(game.week,data.week) # load the games indexed by id information def test_week_games_id_data_present(self): data = self.db.load_week_data(2014,1) self.assertEqual(len(data.games_id),10) for game_id in data.games_id: game = data.games_id[game_id] self.assertEqual(game.week,data.week) self.assertEqual(game_id,game.id) # load the games indexed by id information def test_week_games_are_same(self): data = self.db.load_week_data(2014,1) for game in data.games.values(): self.assertIn(game.id,data.games_id) # load the teams def test_teams_data_present(self): data = self.db.load_week_data(2014,1) self.assertGreater(len(data.teams),0) self.assertIn('Georgia Tech',data.teams) self.assertIn('South Carolina',data.teams) self.assertIn('Clemson',data.teams) self.assertIn(data.teams['Georgia Tech'].team_name,'Georgia Tech') self.assertIn(data.teams['South Carolina'].team_name,'South Carolina') self.assertIn(data.teams['Clemson'].team_name,'Clemson') # load the players def test_players_data_present(self): data = self.db.load_week_data(2014,1) self.assertGreater(len(data.players),0) player_names = [ p.public_name for p in data.players.values() ] self.assertIn('Brent',player_names) self.assertIn('John',player_names) # load the picks def test_picks_data_present(self): data = self.db.load_week_data(2014,1) self.assertGreater(len(data.picks),0) for pick in data.picks.values(): self.assertEqual(pick.game.week.weeknum,1) self.assertEqual(pick.game.week.year.yearnum,2014) # load the player_picks information def test_player_picks_data_present(self): data = self.db.load_week_data(2014,1) self.assertGreater(len(data.player_picks),0) for player_id in data.player_picks: player_picks = data.player_picks[player_id] self.assertEqual(len(player_picks),10) for pick in player_picks: self.assertEqual(pick.player.id,player_id) self.assertEqual(pick.game.week,data.week) def test_get_week_numbers(self): self.__get_weeks_test(2013,[1,2,3,4,5,6,7,8,9,10,11,12,13]) def test_get_week_numbers_bad_year(self): self.__get_weeks_invalid_year_test() def __get_weeks_test(self,year,expected_weeks): d = Database() weeks = d.get_week_numbers(year) self.assertIsNotNone(weeks) self.assertEqual(weeks,expected_weeks) def __get_weeks_invalid_year_test(self): d = Database() with self.assertRaises(Exception): weeks = d.get_week_numbers(1900)
def get(self, request, year, week_number, player_id): if self.__bad_year_or_week_number(year, week_number): data = {'year': year, 'week_number': week_number} return render(request, "pick10/bad_week.html", data, status=400) if not (self.__is_player_id_valid(player_id)): data = {'player_id': player_id, 'error': 'bad_id'} return render(request, "pick10/bad_player.html", data, status=400) year = int(year) week_number = int(week_number) player_id = int(player_id) d = Database() if not (self.__is_player_in_year(player_id, year)): data = {'year': year, 'player_id': player_id, 'error': 'bad_year'} return render(request, "pick10/bad_player.html", data, status=400) if d.is_week_being_setup(year, week_number): data = {'error': 'week_not_setup'} return render(request, "pick10/bad_player.html", data, status=400) access = UserAccess(request.user) # get the timezone for displaying the kickoff date and pick deadline if access.get_profile() == None: timezone = 'US/Eastern' else: timezone = access.get_profile().preferredtz # TODO tests if self.__hide_player_results(access, player_id, year, week_number): pick_deadline_utc = d.get_pick_deadline(year, week_number) pick_deadline = self.__format_pick_deadline( pick_deadline_utc, timezone) data = { 'year': year, 'player_id': player_id, 'error': 'before_pick_deadline', 'deadline': pick_deadline } return render(request, "pick10/bad_player.html", data) use_private_names = access.is_private_user() calc = CalculatePlayerResults(year, week_number, player_id, use_private_names) summary = calc.get_player_summary() results = calc.get_results() self.set_game_status_params(results, timezone) years_in_pool = sorted(d.get_years(), reverse=True) sidebar = render_to_string("pick10/year_sidebar.html", { 'years_in_pool': years_in_pool, 'year': year }) params = dict() params['year'] = year params['week_number'] = week_number params['weeks_in_year'] = d.get_week_numbers(year) params['years_in_pool'] = years_in_pool params['summary'] = summary params['results'] = results params['FINAL'] = FINAL params['IN_PROGRESS'] = IN_PROGRESS params['NOT_STARTED'] = NOT_STARTED params['side_block_content'] = sidebar WeekNavbar(year, week_number, 'player_results', request.user).add_parameters(params) return render(request, "pick10/player_results.html", params)
def post(self, request, year, week_number): if self.__bad_year_or_week_number(year, week_number): data = {'year': year, 'week_number': week_number} return render(request, "pick10/bad_week.html", data) d = Database() year = int(year) week_number = int(week_number) weeks_in_year = d.get_week_numbers(year) cancel_clicked = request.POST.get("cancel_form") if cancel_clicked: return redirect("week_results", year=year, week_number=week_number) if request.user.is_superuser: unlocked_clicked = request.POST.get("unlock_form") if unlocked_clicked: w = get_week(year, week_number) w.lock_scores = False w.save() return redirect("update_games", year=year, week_number=week_number) locked_clicked = request.POST.get("lock_form") if locked_clicked: w = get_week(year, week_number) w.lock_scores = True w.save() return redirect("update_games", year=year, week_number=week_number) submit_clicked = request.POST.get("submit_form") if not submit_clicked: errmsg = "Unexpected Error! Expected submit button to be clicked but wasn't" return render(request, "pick10/error_message.html", message=errmsg) # check user/player privileges # superuser is allowed to access page no matter what access = UserAccess(request.user) if access.is_superuser() == False: # only private player can update scores if access.is_public_user(): data = {'year': year, 'error': 'user_not_participant'} data['years_in_pool'] = sorted(d.get_years(), reverse=True) WeekNavbar(year, week_number, 'update_games', request.user).add_parameters(data) return render(request, "pick10/update_games_error.html", data) # user's player not in the pool this year if access.is_player_in_year(year) == False: player_id = access.get_player().id data = { 'year': year, 'player_id': player_id, 'error': 'bad_year' } data['years_in_pool'] = sorted(d.get_years(), reverse=True) WeekNavbar(year, week_number, 'update_games', request.user).add_parameters(data) return render(request, "pick10/update_games_error.html", data) if d.is_week_being_setup(year, week_number): data = {'year': year, 'error': 'week_not_setup'} data['years_in_pool'] = sorted(d.get_years(), reverse=True) WeekNavbar(year, week_number, 'update_games', request.user).add_parameters(data) return render(request, "pick10/update_games_error.html", data) if self.__is_week_scores_locked(year, week_number): data = { 'year': year, 'week_number': week_number, 'error': 'scores_locked' } data['years_in_pool'] = sorted(d.get_years(), reverse=True) WeekNavbar(year, week_number, 'update_games', request.user).add_parameters(data) return render(response, "pick10/update_games_error.html", data) u = UpdateGames(year, week_number) week_games = u.get_games() try: for game_number in range(1, 11): input_data = self.__get_game_input_data(request, game_number) index = game_number - 1 assert week_games[index].number == game_number week_games[index].team1_score = input_data['team1_score'] week_games[index].team2_score = input_data['team2_score'] week_games[index].quarter = input_data['quarter'] week_games[index].time_left = input_data['time_left'] week_games[index].state = input_data['state'] except BadInputException as e: return render(request, "pick10/error_message.html", message=e.errmsg) u.update_games(week_games) return redirect("update_pages", year=year, week_number=week_number)
def __get_pool_state(self, year): d = Database() pool_state = d.get_pool_state(year) return pool_state
def get(self, request, year, week_number, use_private_names=None, use_memcache=True): loading_memcache = request == None if self.__bad_year_or_week_number(year, week_number): assert not loading_memcache, "When loading memcache, year/week needs to be valid " data = {'year': year, 'week_number': week_number} return render(request, "pick10/bad_week.html", data, status=400) year = int(year) week_number = int(week_number) d = Database() if d.is_week_being_setup(year, week_number): assert not loading_memcache, "Loading memcache does not support week being setup" years_in_pool = sorted(d.get_years(), reverse=True) data = { 'error': 'week_not_setup', 'years_in_pool': years_in_pool, 'year': year } WeekNavbar(year, week_number, 'tiebreak', request.user).add_parameters(data) return render(request, "pick10/tiebreak_error.html", data, status=400) if loading_memcache: use_private_names = use_private_names else: use_private_names = self.__determine_private_access( request.user, use_private_names) # setup memcache parameters if use_private_names: body_key = "tiebreak_private_%d_%d" % (year, week_number) else: body_key = "tiebreak_public_%d_%d" % (year, week_number) years_in_pool = sorted(d.get_years(), reverse=True) sidebar = render_to_string("pick10/year_sidebar.html", { 'years_in_pool': years_in_pool, 'year': year }) # look for hit in the memcache if not loading_memcache and use_memcache: body = cache.get(body_key) memcache_hit = body != None if memcache_hit: data = { 'body_content': body, 'side_block_content': sidebar, 'week_number': week_number } WeekNavbar(year, week_number, 'tiebreak', request.user).add_parameters(data) return render(request, "pick10/tiebreak.html", data) weeks_in_year = d.get_week_numbers(year) tiebreak = CalculateTiebreak(year, week_number, use_private_names) params = dict() params['year'] = year params['week_number'] = week_number params['weeks_in_year'] = weeks_in_year params['years_in_pool'] = years_in_pool params['winner_valid'] = tiebreak.was_able_to_determine_winner() params['featured_game_state'] = tiebreak.get_featured_game_state() params['summary'] = tiebreak.get_tiebreaker_summary() params['tiebreaker0_details'] = tiebreak.get_tiebreaker0_details() params['tiebreaker1_details'] = tiebreak.get_tiebreaker1_details() params['tiebreaker2_details'] = tiebreak.get_tiebreaker2_details() params['tiebreaker3_details'] = tiebreak.get_tiebreaker3_details() params['tiebreaker1_summary'] = tiebreak.get_tiebreaker1_summary() params['tiebreaker2_summary'] = tiebreak.get_tiebreaker2_summary() params['tiebreaker3_summary'] = tiebreak.get_tiebreaker3_summary() params['tiebreaker_required'] = params['summary'] != None and len( params['summary']) > 1 params['tiebreaker0_valid'] = params[ 'tiebreaker0_details'] != None and len( params['tiebreaker0_details']) > 0 params['tiebreaker1_valid'] = params[ 'tiebreaker1_details'] != None and len( params['tiebreaker1_details']) > 0 params['tiebreaker2_valid'] = params[ 'tiebreaker2_details'] != None and len( params['tiebreaker2_details']) > 0 params['tiebreaker3_valid'] = params[ 'tiebreaker3_details'] != None and len( params['tiebreaker3_details']) > 0 params['NOT_STARTED'] = NOT_STARTED params['IN_PROGRESS'] = IN_PROGRESS params['FINAL'] = FINAL body = render_to_string("pick10/tiebreak_body.html", params) cache.set(body_key, body) if loading_memcache: return data = { 'body_content': body, 'side_block_content': sidebar, 'week_number': week_number } WeekNavbar(year, week_number, 'tiebreak', request.user).add_parameters(data) return render(request, "pick10/tiebreak.html", data)
def get(self, request, year, week_number): if self.__bad_year_or_week_number(year, week_number): data = {'year': year, 'week_number': week_number} return render(request, "pick10/bad_week.html", data, status=400) access = UserAccess(request.user) d = Database() year = int(year) week_number = int(week_number) weeks_in_year = d.get_week_numbers(year) years_in_pool = sorted(d.get_years(), reverse=True) # check user/player privileges # superuser is allowed to access page no matter what if access.is_superuser() == False: # only private player can update scores if access.is_public_user(): data = { 'year': year, 'error': 'user_not_participant', 'years_in_pool': years_in_pool } WeekNavbar(year, week_number, 'update_games', request.user).add_parameters(data) return render(request, "pick10/update_games_error.html", data) # user's player not in the pool this year if access.is_player_in_year(year) == False: player_id = access.get_player().id data = { 'year': year, 'player_id': player_id, 'error': 'bad_year', 'years_in_pool': years_in_pool } WeekNavbar(year, week_number, 'update_games', request.user).add_parameters(data) return render(request, "pick10/update_games_error.html", data) if d.is_week_being_setup(year, week_number): data = { 'year': year, 'error': 'week_not_setup', 'years_in_pool': years_in_pool } WeekNavbar(year, week_number, 'update_games', request.user).add_parameters(data) return render(request, "pick10/update_games_error.html", data) params = dict() params['year'] = year params['week_number'] = week_number params['weeks_in_year'] = weeks_in_year params['years_in_pool'] = years_in_pool params['games'] = UpdateGames(year, week_number).get_games() params['locked'] = self.__is_week_scores_locked(year, week_number) params['FINAL'] = FINAL params['IN_PROGRESS'] = IN_PROGRESS params['NOT_STARTED'] = NOT_STARTED WeekNavbar(year, week_number, 'update_games', request.user).add_parameters(params) return render(request, "pick10/update_games.html", params)
from pick10.calculator import CalculateResults #from pick10.models import * from pick10.models import get_profile_by_player, get_staff import django.utils.timezone as tz import datetime import pytz import collegefootballpick10.settings as cfp_settings class PlayerInfo: player = None player_id = None email = None timezone = None players = [] database = Database() def get_current_week(): weeks_and_years = database.load_weeks_and_years() assert weeks_and_years != None years = weeks_and_years.keys() assert years != None and len(years) > 0 current_year = max(weeks_and_years.keys()) weeks = weeks_and_years[current_year] assert weeks != None and len(weeks) > 0 current_week = max(weeks_and_years[current_year])
def __get_weeks_invalid_year_test(self): d = Database() with self.assertRaises(Exception): weeks = d.get_week_numbers(1900)
def __get_weeks_test(self,year,expected_weeks): d = Database() weeks = d.get_week_numbers(year) self.assertIsNotNone(weeks) self.assertEqual(weeks,expected_weeks)
def get(self,request,year,use_private_names=None,use_memcache=True): # TODO how to get final pool state? year = int(year) loading_memcache = request == None d = Database() if not(d.is_year_valid(year)): assert not loading_memcache,"When loading memcache, year needs to be valid " data={'year':year} return render(request,"pick10/bad_year.html",data,status=400) if loading_memcache: access = None else: access = UserAccess(request.user) use_private_names = self.__determine_private_access(access,use_private_names) # setup memcache parameters if use_private_names: body_key = "overall_private_%d" % (year) else: body_key = "overall_public_%d" % (year) pool_state = d.get_pool_state(year) weeks_in_year = d.get_week_numbers(year) last_week_number = weeks_in_year[-1] years_in_pool = sorted(d.get_years(),reverse=True) sidebar = render_to_string("pick10/year_sidebar.html",{'years_in_pool':years_in_pool,'year':year}) if pool_state == "week_setup": # use last weeks results weeks_in_year.remove(last_week_number) last_week_number = last_week_number - 1 # What if we need to go back a year? if last_week_number == 0: year -= 1 pool_state = d.get_pool_state(year) weeks_in_year = d.get_week_numbers(year) last_week_number = weeks_in_year[-1] # look for hit in the memcache if not loading_memcache and use_memcache: body = cache.get(body_key) memcache_hit = body != None if memcache_hit: data = {'body_content':body,'side_block_content':sidebar,'year':year,'weeks_in_year':weeks_in_year } self.__set_player_id(access,data) WeekNavbar(year,last_week_number,'overall',request.user).add_parameters(data) return render(request,"pick10/overall_results.html",data) years_in_pool = sorted(d.get_years(),reverse=True) if pool_state == "not_started": players = d.load_players(year) data={'year':year, 'num_players':len(players)} body = render_to_string("pick10/overall_not_started.html",data) cache.set(body_key,body) if loading_memcache: return data = {'body_content':body,'side_block_content':sidebar,'year':year } WeekNavbar(year,last_week_number,'overall',request.user).add_parameters(data) return render(request,"pick10/overall_results.html",data) completed_games = calc_completed_games(year) self.cor = CalculateOverallResults(year,completed_games,use_private_names,use_weeks=weeks_in_year) results = self.cor.get_results() content_params = dict() content_params['year'] = year content_params['weeks_in_year'] = weeks_in_year content_params['pool_state'] = pool_state content_params['results'] = results content_params['last_week_number'] = last_week_number self.__render_file = "pick10/overall_results_combined.html" params = dict() params['year'] = year params['weeks_in_year'] = weeks_in_year params['years_in_pool'] = years_in_pool params['last_week_number'] = weeks_in_year[-1] params['pool_state'] = pool_state params['results'] = results params['content'] = self.__initial_content(content_params) params['sorted_by_overall'] = self.__sort_by_overall(content_params) params['sorted_by_overall_reversed'] = self.__sort_by_overall_reversed(content_params) params['sorted_by_players'] = self.__sort_by_players(content_params) params['sorted_by_players_reversed'] = self.__sort_by_players_reversed(content_params) if pool_state == "week_not_started": params['sorted_by_projected'] = "" params['sorted_by_projected_reversed'] = "" params['sorted_by_possible'] = self.__sort_by_overall_possible(content_params) params['sorted_by_possible_reversed'] = self.__sort_by_overall_possible_reversed(content_params) elif pool_state == "week_final": params['sorted_by_projected'] = "" params['sorted_by_projected_reversed'] = "" params['sorted_by_possible'] = self.__sort_by_overall_possible(content_params) params['sorted_by_possible_reversed'] = self.__sort_by_overall_possible_reversed(content_params) elif pool_state == "week_in_progress": params['sorted_by_projected'] = self.__sort_by_overall_projected(content_params) params['sorted_by_projected_reversed'] = self.__sort_by_overall_projected_reversed(content_params) params['sorted_by_possible'] = self.__sort_by_overall_possible(content_params) params['sorted_by_possible_reversed'] = self.__sort_by_overall_possible_reversed(content_params) else: params['sorted_by_projected'] = "" params['sorted_by_projected_reversed'] = "" params['sorted_by_possible'] = "" params['sorted_by_possible_reversed'] = "" body = render_to_string("pick10/overall_results_body.html",params) cache.set(body_key,body) if loading_memcache: return data = {'body_content':body,'side_block_content':sidebar,'year':year,'weeks_in_year':weeks_in_year } self.__set_player_id(access,data) WeekNavbar(year,last_week_number,'overall',request.user).add_parameters(data) return render(request,"pick10/overall_results.html",data)
def __is_player_in_year(self, player_id, year): d = Database() players_in_year = d.load_players(year) return player_id in players_in_year
pass player = utils.get_player_from_public_name(1978, 'Brent') utils.login_assigned_user('Brent', player=player) utils.login_unassigned_user('user1') ############################################################################## from pick10.models import * from pick10.tests.unit_test_database import UnitTestDatabase from pick10.calculator import CalculateResults, FINAL from pick10.database import Database from pick10.calculate_tiebreak import CalculateTiebreak from pick10.week_winner import WeekWinner yearnum = 1978 weeknum = 1 playerid = 1 test_db = UnitTestDatabase() test_db.setup_week_final(yearnum, weeknum) test_db.setup_week_no_picks(yearnum, weeknum + 1, FINAL) database = Database() week_data = database.load_week_data(yearnum, weeknum) calc = CalculateResults(week_data) player = week_data.players[playerid] week = week_data.week game = calc.get_featured_game() winners = WeekWinner(yearnum, weeknum) calc.get_player_submit_time(player, week) ctb = CalculateTiebreak(yearnum, weeknum)