예제 #1
0
 def round_with_results(self):
     from results.controllers.ResultsController import ResultsController
     controller = ResultsController()
     if controller.results_entered_for_round(self.round):
         return self.round
     else:
         return self.round - 1
예제 #2
0
파일: views.py 프로젝트: sarrionandia/taber
    def get(self, request):

        team_standing_controller = TeamStandingController()
        results_controller = ResultsController()
        max_round = results_controller.max_round_with_results()

        template = loader.get_template('display/team_standing.html')
        context = RequestContext(request, {
            'table' : team_standing_controller.team_standing_table_all_rounds(),
            'max_round' : max_round,
            'all_rounds' : range(1, max_round+1)
        })
        return HttpResponse(template.render(context))
예제 #3
0
class TeamStandingController:

    points_controller = None
    results_controller = None

    def __init__(self):
        self.points_controller = PointsController()
        self.results_controller = ResultsController()

    def team_standing_table_all_rounds(self):
        return self.team_standing_table(self.results_controller.max_round_with_results())

    def team_standing_table(self, max_round):
        rows = []
        teams = list(Team.objects.all())
        teams.sort(key=lambda team: (team.total_team_points, team.total_speaker_sum), reverse=True)
        for t in range(0, len(teams)):
            team = teams[t]
            if (team.total_speaker_sum == teams[t - 1].total_speaker_sum) and (
                team.total_team_points == teams[t - 1].total_team_points
            ):
                row = ["--", team]
            else:
                row = [t + 1, team]
            for r in range(1, max_round + 1):
                row.append(self.points_controller.team_points_for_team(team, r))
            row.append(team.total_speaker_sum)
            row.append(team.total_team_points)
            rows.append(row)
        return rows
예제 #4
0
파일: views.py 프로젝트: sarrionandia/taber
    def get(self, request):
        template = loader.get_template('draw/index.html')

        team_count = Team.objects.all().count()
        results_controller = ResultsController()
        tournament = Tournament.instance()

        context = RequestContext(request, {
            'teams_count' : Team.objects.all().count(),
            'teams_ok' : (team_count % 4 == 0) and (team_count >= 4),
            'rooms' : team_count / 4,
            'venues_ok' : Venue.objects.all().count() >= team_count/4,
            'tournament' : tournament,
            'this_round' : tournament.round,
            'next_round' : tournament.round + 1,
            'results_entered' : results_controller.results_entered_for_round(tournament.round)
        })
        return HttpResponse(template.render(context))
예제 #5
0
class PointsController():

    results_controller = None

    def __init__(self):
        self.results_controller = ResultsController()

    def team_points_for_team(self, team, round):
        result = self.results_controller.result_for_team(team, round)
        debate = result.debate

        if debate.OG == team:
            return result.og
        if debate.OO == team:
            return result.oo
        if debate.CG == team:
            return result.cg
        if debate.CO == team:
            return result.co

    def total_points_for_team(self, team, maxround):
        total = 0
        for round in range(1, maxround+1):
            total += self.team_points_for_team(team, round)
        return total

    def speaker_points_for_team(self, team, round):
        result = self.results_controller.result_for_team(team, round)
        debate = result.debate

        if debate.OG == team:
            return [result.ogsp1, result.ogsp2]
        if debate.OO == team:
            return [result.oosp1, result.oosp2]
        if debate.CG == team:
            return [result.cgsp1, result.cgsp2]
        if debate.CO == team:
            return [result.cosp1, result.cosp2]

    def team_points_map_for_round(self, round, teams):
        points = {}
        for team in teams:
            points.update({team: self.team_points_for_team(team, round)})
        return points
예제 #6
0
    def setUp(self):
        self.resultController = ResultsController()

        self.result = Result()
        self.debate = MagicMock()
        self.debateController = MagicMock()
        self.team = MagicMock

        self.debateController.debate_for_round.return_value = self.debate
        self.debate.result.return_value = self.result

        self.resultController.debate_controller = self.debateController
예제 #7
0
class ResultControllerTestCase(TestCase):

    def setUp(self):
        self.resultController = ResultsController()

        self.result = Result()
        self.debate = MagicMock()
        self.debateController = MagicMock()
        self.team = MagicMock

        self.debateController.debate_for_round.return_value = self.debate
        self.debate.result.return_value = self.result

        self.resultController.debate_controller = self.debateController

    def testRaisesExceptionForRoundNotDrawn(self):
        tournament = Tournament.instance()
        tournament.round = 1
        tournament.save()
        with self.assertRaises(TournamentStateException):
            self.resultController.results_entered_for_round(10)

    def testReturnsFalseForRoundWithoutAnyResults(self):
        generate_objects.setup_IV_R1()
        self.assertFalse(self.resultController.results_entered_for_round(1), "No results entered but returned true")

    def testReturnsTrueForRoundWithAllResults(self):
        generate_objects.setup_IV_R1()

        for debate in Debate.objects.filter(round=1):
            generate_objects.valid_result_given_debate(debate)

        self.assertTrue(self.resultController.results_entered_for_round(1), "All results entered but returned false")

    def testReturnsFalseForPartiallyEnteredRound(self):
        generate_objects.setup_IV_R1()
        generate_objects.valid_result_given_debate(Debate.objects.first())

        self.assertFalse(self.resultController.results_entered_for_round(1), "Only some results entered but returned true")

    def testGetResultForRound(self):
        return_value = self.resultController.result_for_team(self.team, 1)
        self.assertEqual(self.debate.result, return_value)
예제 #8
0
class DrawController:

    resultsController = None
    pointsController = None

    def __init__(self):
        self.resultsController = ResultsController()
        self.pointsController = PointsController()

    def draw_next_round(self):
        tournament = Tournament.instance()
        next_round = tournament.round + 1
        pools = self.create_pools(Team.objects.all(), tournament.round)
        pools = self.remove_empty(pools)
        pools = self.shuffle_pools(pools)
        pools = self.balance_pools(pools)
        debates = self.draw_from_pools(next_round, pools)
        tournament.round = next_round
        tournament.save()
        mapper = VenueMapper()
        mapper.map_venues(next_round)
        return debates

    def create_pools(self, teams, max_round):
        if not self.resultsController.results_entered_for_round(Tournament.instance().round):
            raise TournamentStateException("All results for current round must be entered to draw")
        pools = self.create_blank_pools(max_round)

        for team in teams:
            points = self.pointsController.total_points_for_team(team, 1)
            pools[points].append(team)

        return pools

    @staticmethod
    def create_blank_pools(max_round):
        pools = {}
        if max_round == 0:
            return pools

        for points in range(0, 4 + ((max_round - 1) * 3)):
            pools.update({points: []})
        return pools

    @staticmethod
    def remove_empty(pools):
        keys = pools.keys()
        for key in keys:
            pool = pools[key]
            if len(pool) < 1:
                pools.pop(key)
        return pools

    @staticmethod
    def next_viable_pool(current, pools):
        for i in range(current + 1, len(pools.values())):
            next_pool = pools.values()[i]
            if len(next_pool) != 0:
                return next_pool
        raise ValueError("No viable pool")

    @staticmethod
    def shuffle_pools(pools):
        for pool in pools.values():
            random.shuffle(pool)
        return pools

    def balance_pools(self, pools):
        flattened_pools = [item for sublist in pools.values() for item in sublist]
        if len(flattened_pools) % 4 != 0:
            raise ValueError("Number of teams must be divisible by 4")

        made_swap = True
        while made_swap:
            made_swap = False
            for i in range(0, len(pools.values())):
                pool = pools.values()[i]
                if (len(pool) % 4 != 0) and pool != pools.values()[-1]:
                    teams_needed = 4 - (len(pool) % 4)
                    for t in range(0, teams_needed):
                        source_pool = self.next_viable_pool(i, pools)
                        pool.append(source_pool.pop(0))
                        made_swap = True

        return pools

    def draw_from_pools(self, round, pools):
        debates = []
        for pool in pools.values():
            if len(pool) % 4 != 0:
                raise ValueError("Number of teams must be divisible by four")

            num_debates = len(pool) / 4

            for i in range(0, num_debates):
                debate = Debate(round=round)
                debate.OG = pool[(i * 4)]
                debate.OO = pool[(i * 4) + 1]
                debate.CG = pool[(i * 4) + 2]
                debate.CO = pool[(i * 4) + 3]
                debate.full_clean()
                debate.save()
                debates.append(debate)
        return debates
예제 #9
0
 def __init__(self):
     self.resultsController = ResultsController()
     self.pointsController = PointsController()
예제 #10
0
 def __init__(self):
     self.results_controller = ResultsController()