def test_get_previous_next_active_phase_works_with_competition_that_has_ended_but_has_phase_that_never_ends(
            self):
        self.competition.end_date = datetime(2018,
                                             5,
                                             25,
                                             23,
                                             59,
                                             tzinfo=pytz.utc)
        self.competition.save()

        self.phase_1 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=1,
            start_date=datetime(2017, 6, 18, 23, 59),
        )
        self.phase_2 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=2,
            start_date=datetime(2017, 6, 30, 23, 59),
            phase_never_ends=True,
        )
        self.phase_3 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=3,
            start_date=datetime(2018, 5, 13, 23, 59),
        )

        first_phase, previous_phase, active_phase, next_phase = get_first_previous_active_and_next_phases(
            self.competition)
        assert first_phase == self.phase_1
        assert previous_phase == self.phase_3
        assert active_phase == self.phase_2
        assert next_phase is None
Beispiel #2
0
    def get_serializer_context(self, *args, **kwargs):
        context = super(CompetitionSubmissionListViewSet,
                        self).get_serializer_context(*args, **kwargs)

        # To reduce queries, let's collect a bit of data to make processing submissions easier
        competition_id = self.kwargs['competition_id']
        context[
            'leaderboard_submissions'] = PhaseLeaderBoardEntry.objects.filter(
                board__phase__competition_id=competition_id).values_list(
                    'result__id', flat=True)

        first_phase, previous_phase, active_phase, next_phase = get_first_previous_active_and_next_phases(
            Competition.objects.get(pk=competition_id))

        # Get all submissions that can be migrated into another phase (must be on leaderboard already and
        # the next phase must have auto_migration = True)
        if next_phase and next_phase.auto_migration:
            active_phase_submissions = active_phase.submissions.all(
            ).values_list('id', flat=True)
            context['migratable_submissions'] = filter(
                lambda x: x in context["leaderboard_submissions"],
                active_phase_submissions)
        else:
            context['migratable_submissions'] = []

        return context
    def test_get_previous_next_active_phase_works_with_neverending_second_phase(
            self):
        self.phase_1 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=1,
            start_date=datetime(2017, 6, 18, 23, 59),
        )
        self.phase_2 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=2,
            start_date=datetime(2017, 6, 30, 23, 59),
            phase_never_ends=True,
        )
        self.phase_3 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=3,
            start_date=datetime(2018, 5, 13, 23, 59),
        )

        first_phase, previous_phase, active_phase, next_phase = get_first_previous_active_and_next_phases(
            self.competition)
        assert first_phase == self.phase_1
        assert previous_phase == self.phase_2
        assert active_phase == self.phase_3
        assert next_phase is None
    def test_get_previous_next_active_phase_works_many_phases(self):
        self.phase_1 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=1,
            start_date=now() - timedelta(days=30),
        )
        self.phase_2 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=2,
            start_date=now() - timedelta(days=15),
        )
        self.phase_3 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=3,
            start_date=now() - timedelta(days=5),
        )
        self.phase_4 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=4,
            start_date=now() + timedelta(days=15),
        )

        first_phase, previous_phase, active_phase, next_phase = get_first_previous_active_and_next_phases(
            self.competition)
        assert first_phase == self.phase_1
        assert previous_phase == self.phase_2
        assert active_phase == self.phase_3
        assert next_phase == self.phase_4
    def test_get_previous_next_active_phase_works_with_competition_that_has_ended_but_has_phase_that_never_ends(self):
        self.competition.end_date = datetime(2018, 5, 25, 23, 59, tzinfo=pytz.utc)
        self.competition.save()

        self.phase_1 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=1,
            start_date=datetime(2017, 6, 18, 23, 59),
        )
        self.phase_2 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=2,
            start_date=datetime(2017, 6, 30, 23, 59),
            phase_never_ends=True,
        )
        self.phase_3 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=3,
            start_date=datetime(2018, 5, 13, 23, 59),
        )

        first_phase, previous_phase, active_phase, next_phase = get_first_previous_active_and_next_phases(
            self.competition)
        assert first_phase == self.phase_1
        assert previous_phase == self.phase_3
        assert active_phase == self.phase_2
        assert next_phase is None
    def test_get_previous_next_active_phase_works_many_phases(self):
        self.phase_1 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=1,
            start_date=now() - timedelta(days=30),
        )
        self.phase_2 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=2,
            start_date=now() - timedelta(days=15),
        )
        self.phase_3 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=3,
            start_date=now() - timedelta(days=5),
        )
        self.phase_4 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=4,
            start_date=now() + timedelta(days=15),
        )

        first_phase, previous_phase, active_phase, next_phase = get_first_previous_active_and_next_phases(self.competition)
        assert first_phase == self.phase_1
        assert previous_phase == self.phase_2
        assert active_phase == self.phase_3
        assert next_phase == self.phase_4
    def test_get_previous_next_active_phase_works_without_neverending_second_phase(self):
        self.phase_1 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=1,
            start_date=datetime(2017, 6, 18, 23, 59),
        )
        self.phase_2 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=2,
            start_date=datetime(2017, 6, 30, 23, 59),
        )
        self.phase_3 = CompetitionPhase.objects.create(
            competition=self.competition,
            phasenumber=3,
            start_date=datetime(2018, 5, 13, 23, 59),
        )

        first_phase, previous_phase, active_phase, next_phase = get_first_previous_active_and_next_phases(self.competition)
        assert first_phase == self.phase_1
        assert previous_phase == self.phase_2
        assert active_phase == self.phase_3
        assert next_phase is None