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 setUp(self):
self.db = Database()
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 __get_weeks_test(self,year,expected_weeks):
d = Database()
weeks = d.get_week_numbers(year)
self.assertIsNotNone(weeks)
self.assertEqual(weeks,expected_weeks)
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
def __get_weeks_invalid_year_test(self):
d = Database()
with self.assertRaises(Exception):
weeks = d.get_week_numbers(1900)
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)
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)
