padelclub_backend/tournaments/models/tournament.py

from django.db import models
from . import Event, CustomUser, FederalMatchCategory, FederalCategory, FederalLevelCategory, FederalAgeCategory
import uuid
from django.utils import timezone, formats

class Tournament(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=True)
    event = models.ForeignKey(Event, blank=True, null=True, on_delete=models.CASCADE)
    creator = models.ForeignKey(CustomUser, blank=True, null=True, on_delete=models.CASCADE)
    name = models.CharField(max_length=200, null=True, blank=True)
    start_date = models.DateTimeField()
    end_date = models.DateTimeField(null=True, blank=True)
    creation_date = models.DateTimeField()
    is_private = models.BooleanField(default=False)
    # format = models.IntegerField(default=FederalMatchCategory.NINE_GAMES, choices=FederalMatchCategory.choices, null=True, blank=True)
    round_format = models.IntegerField(default=FederalMatchCategory.NINE_GAMES, choices=FederalMatchCategory.choices, null=True, blank=True)
    group_stage_format = models.IntegerField(default=FederalMatchCategory.NINE_GAMES, choices=FederalMatchCategory.choices, null=True, blank=True)
    loser_round_format = models.IntegerField(default=FederalMatchCategory.NINE_GAMES, choices=FederalMatchCategory.choices, null=True, blank=True)
    bracket_sort_mode = models.IntegerField(default=0)
    group_stage_count = models.IntegerField(default=0)
    rank_source_date = models.DateTimeField(null=True, blank=True)
    # custom_name = models.CharField(max_length=100, null=True, blank=True)
    day_duration = models.IntegerField(default=0)
    team_count = models.IntegerField(default=0)
    team_sorting = models.IntegerField(default=0)
    federal_category = models.IntegerField(default=FederalCategory.MEN, choices=FederalCategory.choices) # optional ?
    federal_level_category = models.IntegerField(default=FederalLevelCategory.P100, choices=FederalLevelCategory.choices)
    federal_age_category = models.IntegerField(default=FederalAgeCategory.SENIOR, choices=FederalAgeCategory.choices)
    group_stage_court_count = models.IntegerField(null=True, blank=True)
    seed_count = models.IntegerField(default=0)
    closed_registration_date = models.DateTimeField(null=True, blank=True)
    group_stage_additional_qualified = models.IntegerField(default=0)
    court_count = models.IntegerField(null=True, blank=True)
    prioritize_club_members = models.BooleanField()
    qualified_per_group_stage = models.IntegerField(default=0)
    teams_per_group_stage = models.IntegerField(default=0)
    #estimated_end_date = models.DateTimeField(null=True, blank=True)

    def __str__(self):
        if self.name:
            return self.name
        elif self.event:
            return self.event.display_name()
        else:
            return '--'

    def level(self):
        return self.get_federal_level_category_display()

    def category(self):
        return self.get_federal_category_display()

    def formatted_start_date(self):
        return self.start_date.strftime("%d/%m/%y")

    def in_progress(self):
        return self.end_date is None

    def team_summons(self):
        summons = []
        for team_registration in self.teamregistration_set.all():
            next_match = team_registration.next_match()
            if next_match:
                names = team_registration.team_names()
                stage = next_match.stage_name()
                weight = team_registration.weight()
                summon = TeamSummon(names, next_match.start_date, weight, stage, team_registration.logo)
                summons.append(summon)

        summons.sort(key=lambda s: s.weight)
        return summons

    def live_matches(self, broadcasted, group_stage_id, round_id):

        matches = []
        if group_stage_id:
            matches = self.group_stage_matches(group_stage_id)
        elif round_id:
            matches = self.round_matches(round_id)
        else:
            matches = self.all_matches()

        # matches = [m for m in matches if m.broadcasted==True]
        if not broadcasted:
            matches = [m for m in matches if len(m.team_scores.all()) > 0]

        matches.sort(key=lambda m: m.order)

        return [match.live_match() for match in matches]
        # return map(lambda match: match.live_match(), matches)

    def all_matches(self):
        matches = []
        for group_stage in self.groupstage_set.all():
            for match in group_stage.match_set.all():
                matches.append(match)
        for round in self.round_set.all():
            for match in round.match_set.all():
                matches.append(match)
        return matches

    def group_stage_matches(self, group_stage_id):
        group_stage = self.groupstage_set.filter(id=group_stage_id).first()
        return group_stage.match_set.all()

    def round_matches(self, round_id):
        round = self.round_set.filter(id=round_id).first()
        return round.match_set.all()

    def live_group_stages(self):
        return [gs.live_group_stages() for gs in self.groupstage_set.all()]

class TeamSummon:
    def __init__(self, names, date, weight, stage, image):
        self.names = names
        self.date = date
        self.weight = weight
        self.stage = stage
        self.image = image

    def formatted_date(self):
        timezoned_datetime = timezone.localtime(self.date)
        return formats.date_format(timezoned_datetime, format='H:i')

    def to_dict(self):
            return {
                "names": self.names,
                "date": self.formatted_date(),
                "weight": self.weight,
                "stage": self.stage,
                "image": self.image,
            }