def test_stats(self): t1_skill = 10 t2_skill = 0 team1 = Team("T1", t1_skill, True, "1") team2 = Team("T2", t2_skill, True, "2") record1 = Record(1, team1, 1, 0, 0, 0, 0, 0, 0, "3") record2 = Record(1, team2, 1, 0, 0, 0, 0, 0, 0, "3") rules = GameRules("Rules", True, "4") for i in range(1000): game = Game(1, 1, team1, team2, 0, 0, False, False, rules, str(i)) game.play() record1.process_game(game.home_score, game.away_score) record2.process_game(game.away_score, game.home_score) print() print("Results") print(RecordView.get_table_header()) print( RecordView.get_table_row( RecordService.get_view_from_model(record1))) print( RecordView.get_table_row( RecordService.get_view_from_model(record2)))
def get_current_standings_view(): record_service = RecordService() app_service = AppService() current_data = app_service.get_current_data() records = record_service.get_by_year(current_data.current_year) record_service.sort_default(records) return StandingsCurrentViewModel(current_data, records)
def get_standings_team_history_view(team_id): record_service = RecordService() app_service = AppService() team_service = TeamService() team = team_service.get_by_id(team_id) teams = team_service.get_all() current_data = app_service.get_current_data() records = record_service.get_by_team(team_id) record_service.sort_by_year(records) return StandingsTeamHistoryViewModel(current_data, team.name, records, teams)
def test_get_by_year(self): self.setup_test() team_service = TeamService() service = RecordService() for i in range(10): team_service.create("Team " + str(i), 5, True) teams = team_service.get_all() [service.add(team_service.get_all(), 25)] [service.add(team_service.get_all(), 35)] [service.add(team_service.get_all(), 2)] self.assertEqual(10, len(service.get_by_year(2)))
def print_group(group_name, table_to_print, description): group = competition.get_group_by_name(group_name) recs = TableSubCompetition.get_records_by_group(group, table_to_print.records) recs.sort(key=lambda rec: rec.rank) print(description) print(RecordView.get_table_header()) for r in recs: print(RecordView.get_table_row(RecordService.get_view_from_model(r)))
def get_standings_history_view(year): record_service = RecordService() app_service = AppService() current_data = app_service.get_current_data() records = record_service.get_by_year(year) record_service.sort_default(records) seasons = record_service.get_all_seasons_for_dropdown() seasons.sort(reverse=True) return StandingsHistoryViewModel(current_data, year, records, seasons)
def test_should_get_standings_history_view(self): self.setup_test() team_service = TeamService() record_service = RecordService() app_service = AppService() app_service.setup_data(35, 1, True, True) standings_service = StandingsService() for i in range(10): team_service.create("Team " + str(i), 5, True) record_service.add(team_service.get_all(), 25) record_service.add(team_service.get_all(), 35) record_service.add(team_service.get_all(), 2) result = standings_service.get_standings_history_view(2) self.assertEqual(10, len(result.records))
def test_add_get_by_year_get_by_team(self): self.setup_test() team_service = TeamService() service = RecordService() for i in range(10): team_service.create("Team " + str(i), 5, True) teams = team_service.get_all() [service.add(team_service.get_all(), 25)] [service.add(team_service.get_all(), 35)] [service.add(team_service.get_all(), 2)] result = service.get_by_year(35) [self.assertEqual(35, r.year) for r in result] result = service.get_by_team_and_year(teams[6].oid, 35) self.assertEqual(teams[6].oid, result.team_id, "by year and team") self.assertEqual(35, result.year, "by year and team")
Database.init_db(db_connection_string) if setup: Database.clean_up_database(Database.get_session()) data_setup.setup() if add_teams: data_setup.add_new_teams() team_service = TeamService() for t in team_service.get_all(): print(t.name + " " + str(t.skill)) game_service = GameService() record_service = RecordService() game_rules_service = GameRulesService() app_service = AppService() rules = game_rules_service.get_by_name(rules_name) game_data = app_service.get_current_data() if game_data.is_year_finished: app_service.go_to_next_year() app_service.setup_year(rules, rounds, do_home_and_away) while not app_service.is_year_complete(): game_data = app_service.get_current_data() # print("Playing games on day " + str(game_data.current_day)) r = random app_service.play_and_process_games_for_current_day(r) os.system('cls')
class GameService(BaseService): team_service = TeamService() record_service = RecordService() repo = GameRepository() team_repo = TeamRepository() record_repo = RecordRepository() game_rules_repo = GameRulesRepository() def create_game_from_schedule_game(self, schedule_game, session=None): commit = False if session is None: session = self.repo.get_session() commit = True team_a = self.team_repo.get_by_oid(schedule_game.home_team, session) team_b = self.team_repo.get_by_oid(schedule_game.away_team, session) rules = self.game_rules_repo.get_by_oid(schedule_game.rules, session) if team_a is None: raise AttributeError("Team A cannot be none.") if team_b is None: raise AttributeError("Team B cannot be none.") game = Game(schedule_game.year, schedule_game.day, team_a, team_b, 0, 0, False, False, rules, self.get_new_id()) if commit: session.Commit() return game def create_games(self, team_list, year, start_day, rules, rounds, home_and_away, session=None): if session is None: session = self.repo.get_session() scheduler = Scheduler() team_ids = [i.oid for i in team_list] schedule_games = [] # schedule_games = scheduler.schedule_games(team_ids, rules.oid, year, start_day, home_and_away) for i in range(rounds): schedule_games.extend( scheduler.schedule_games(team_ids, rules.oid, year, start_day, home_and_away)) start_day = max([sg.day for sg in schedule_games]) start_day += 1 new_games = [ self.create_game_from_schedule_game(sg, session) for sg in schedule_games ] [self.repo.add(g, session) for g in new_games] session.commit() @staticmethod def games_to_game_day_view(games): game_vm = [GameService.game_to_vm(g) for g in games] return GameDayViewModel(None, game_vm[0].day, game_vm[0].year, game_vm) @staticmethod def game_to_vm(g): return GameViewModel(g.oid, g.year, g.day, g.home_team.name, g.home_team.oid, g.away_team.name, g.away_team.oid, g.home_score, g.away_score, g.complete) def get_all_games(self): session = self.get_session() return [self.game_to_vm(g) for g in self.repo.get_all(session)] def play_game(self, game_list, random, session=None): commit = session is None session = self.get_session(session) for g in game_list: game = self.repo.get_by_oid(g.oid, session) game.play() self.commit(session, commit) def get_games_for_days(self, year, first_day, last_day, session=None): commit = session is None session = self.get_session() result = self.repo.get_games_by_day(year, first_day, last_day, session) self.commit(session, commit) return [self.game_to_vm(g) for g in result] def play_games_for_days(self, year, first_day, last_day, random, session=None): commit = session is None session = self.get_session(session) games = self.repo.get_games_by_day(year, first_day, last_day, session) self.play_game(games, random, session) self.commit(session, commit) return [ self.game_to_vm(g) for g in self.repo.get_games_by_day( year, first_day, last_day, session) ] def get_incomplete_games_for_days(self, year, first_day, last_day, session=None): session = self.get_session(session) return [ self.game_to_vm(g) for g in self.repo.get_incomplete_or_unprocessed_games_by_day( year, first_day, last_day, session) ] def get_complete_and_unprocessed_games_for_days(self, year, first_day, last_day, session=None): session = self.get_session(session) return [ self.game_to_vm(g) for g in self.repo.get_by_unprocessed_and_complete( year, first_day, last_day, session) ] # processing games needs to go to a higher level so we can know how to process a given game def process_games_for_days(self, year, first_day, last_day, session=None): commit = session is None session = self.get_session(session) games_to_process = self.repo.get_by_unprocessed_and_complete( year, first_day, last_day, session) for game in games_to_process: home_record = self.record_repo.get_by_team_and_year( game.home_team.oid, year, session) away_record = self.record_repo.get_by_team_and_year( game.away_team.oid, year, session) home_record.process_game(game.home_score, game.away_score) away_record.process_game(game.away_score, game.home_score) game.processed = True self.commit(session, commit) def process_games_before(self, year, before_this_day, session=None): raise NotImplementedError def get_incomplete_games_by_year_count(self, year, session=None): session = self.get_session(session) repo = GameRepository() return repo.get_incomplete_or_unprocessed_games_by_year_count( year, session)