add some team stat

tournaments/models/team_registration.py

@@ -172,10 +172,32 @@ class TeamRegistration(models.Model):
             'points_earned': self.get_points_earned(),
             'initial_stage': self.get_initial_stage(),
             'matches_played': self.count_matches_played(),
-            'victory_ratio': self.calculate_victory_ratio()
+            'victory_ratio': self.calculate_victory_ratio(),
+            'team_rank': self.team_rank_label(),
+            'total_teams': self.total_teams(),
         }
         return stats
 
+    def team_rank(self):
+        teams = self.tournament.teams(False)  # Get list of TeamItem objects
+        try:
+            # Find the TeamItem that corresponds to this TeamRegistration
+            team_index = next(i for i, team in enumerate(teams)
+                            if team.team_registration.id == self.id)
+            return team_index + 1
+        except (StopIteration, ValueError):
+            return None
+
+    def team_rank_label(self):
+        team_rank = self.team_rank()
+        if team_rank is None:
+            return "--"
+        return f"{team_rank}"
+
+    def total_teams(self):
+        teams = self.tournament.teams(False)
+        return f"{len(teams)}"
+
     def get_initial_stage(self):
         matches = self.get_matches().order_by('start_date')
         first_match = matches.first()
@@ -191,9 +213,21 @@ class TeamRegistration(models.Model):
         if self.final_ranking:
             if self.final_ranking == 1:
                 return "1er"
-            return f"{self.final_ranking}e"
+            return f"{self.final_ranking}ème" + self.ranking_delta()
         return None
 
+    def ranking_delta(self):
+        team_rank = self.team_rank()
+        if team_rank is None or self.final_ranking is None:
+            return ""
+
+        sign = "-"
+        if team_rank > self.final_ranking:
+            sign = "+"
+        if team_rank == self.final_ranking:
+            sign = ""
+        return f" ({sign}"+f"{team_rank})"
+
     def get_points_earned(self):
         return self.points_earned
 
@@ -220,6 +254,6 @@ class TeamRegistration(models.Model):
         total_matches = matches.count()
         if total_matches > 0:
             wins = matches.filter(winning_team_id=self.id).count()
-            ratio = (wins / total_matches) * 100
+            # ratio = (wins / total_matches) * 100
             return f"{wins}/{total_matches}"
         return None

tournaments/models/tournament.py

@@ -324,126 +324,94 @@ class Tournament(models.Model):
             print("else", index, self.team_count)
             return -1
 
-    def teams(self, includeWaitingList):
+    def teams(self, include_waiting_list):
-        # print("Starting teams method")
+        """
-        bracket_teams = []
+        Get sorted list of teams for the tournament.
-        group_stage_teams = []
+
-        waiting_teams = []
+        Args:
-        teams = []
+            include_waiting_list (bool): Whether to include teams in waiting list
+
+        Returns:
+            list: List of TeamItem objects sorted according to tournament rules
+        """
+        # Initialize team categories
+        complete_teams = []
         wildcard_bracket = []
         wildcard_group_stage = []
-        complete_teams = []
+        waiting_teams = []
-        closed_registration_date = self.closed_registration_date
-        # print(f"Closed registration date: {closed_registration_date}")
 
-        for team_registration in self.teamregistration_set.all():
+        # Get registration cutoff date
-            # print(f"Processing team registration: {team_registration}")
+        closed_date = self.closed_registration_date
-            is_valid = False
+
-            if closed_registration_date is not None and team_registration.registration_date is not None and team_registration.registration_date <= closed_registration_date:
+        # Process each team registration
-                is_valid = True
+        for team_reg in self.teamregistration_set.all():
-            if closed_registration_date is None:
+            if team_reg.out_of_tournament():
-                is_valid = True
+                continue
-            if team_registration.registration_date is None:
+
-                is_valid = True
+            # Create team item
-            # print(f"Is valid: {is_valid}")
+            team = TeamItem(team_reg)
-            if team_registration.out_of_tournament() is False:
+
-                team = TeamItem(team_registration)
+            # Determine if registration is valid based on date
-                # print(f"Created team: {team}")
+            is_valid = (
-                if team_registration.group_stage_position is not None:
+                closed_date is None or
-                    team.set_stage("Poule")
+                team_reg.registration_date is None or
-                elif team_registration.bracket_position is not None:
+                (team_reg.registration_date and team_reg.registration_date <= closed_date)
-                    team.set_stage("Tableau")
+            )
-                else:
-                    team.set_stage("Attente")
-                # print(f"Team stage: {team.stage}")
 
-                teams.append(team)
+            # Categorize team
-                if team_registration.wild_card_bracket:
+            if team_reg.wild_card_bracket:
                 wildcard_bracket.append(team)
-                elif team_registration.wild_card_group_stage:
+            elif team_reg.wild_card_group_stage:
                 wildcard_group_stage.append(team)
-                elif is_valid is True:
+            elif is_valid:
                 complete_teams.append(team)
             else:
                 waiting_teams.append(team)
 
-        # print(f"Total teams: {len(teams)}")
+            # Set initial stage
-        # print(f"Wildcard bracket: {len(wildcard_bracket)}")
+            if team_reg.group_stage_position is not None:
-        # print(f"Wildcard group stage: {len(wildcard_group_stage)}")
-        # print(f"Complete teams: {len(complete_teams)}")
-        # print(f"Waiting teams: {len(waiting_teams)}")
-
-        if len(teams) < self.team_count:
-            teams.sort(key=lambda s: (s.initial_weight, s.team_registration.id))
-            return teams
-
-        seeds_count = min(self.team_count, len(teams)) - self.group_stage_count * self.teams_per_group_stage - len(wildcard_bracket)
-        group_stage_members_count = self.group_stage_count * self.teams_per_group_stage - len(wildcard_group_stage)
-        if group_stage_members_count < 0:
-            group_stage_members_count = 0
-        if seeds_count < 0:
-            seeds_count = 0
-        # print(f"Seeds count: {seeds_count}")
-        # print(f"Group stage members count: {group_stage_members_count}")
-
-        if self.team_sorting == TeamSortingType.INSCRIPTION_DATE:
-            complete_teams.sort(key=lambda s: (s.registration_date is None, s.registration_date or datetime.min, s.initial_weight, s.team_registration.id))
-        else:
-            complete_teams.sort(key=lambda s: (s.initial_weight, s.team_registration.id))
-
-        selected_teams = complete_teams[:self.team_count]
-        selected_teams.sort(key=lambda s: (s.initial_weight, s.team_registration.id))
-
-        if seeds_count > 0:
-            bracket_teams = selected_teams[:seeds_count] + wildcard_bracket
-        else:
-            bracket_teams = []
-        # print(f"Bracket teams: {len(bracket_teams)}")
-
-        if group_stage_members_count:
-            group_stage_end = seeds_count + group_stage_members_count
-            group_stage_teams = selected_teams[seeds_count:group_stage_end] + wildcard_group_stage
-        else:
-            group_stage_teams = []
-        # print(f"Group stage teams: {len(group_stage_teams)}")
-
-        waiting_list_count = len(teams) - self.team_count
-        if waiting_list_count < 0:
-            waiting_list_count = 0
-        # print(f"Waiting list count: {waiting_list_count}")
-
-        if waiting_list_count > 0 or len(waiting_teams) > 0:
-            if waiting_list_count > 0:
-                waiting_teams = waiting_teams + complete_teams[-waiting_list_count:]
-            if self.team_sorting == TeamSortingType.INSCRIPTION_DATE:
-                waiting_teams.sort(key=lambda s: (s.registration_date is None, s.registration_date or datetime.min, s.initial_weight, s.team_registration.id))
-            else:
-                waiting_teams.sort(key=lambda s: (s.initial_weight, s.team_registration.id))
-        else:
-             waiting_teams = []
-        # print(f"Final waiting teams: {len(waiting_teams)}")
-
-        bracket_teams.sort(key=lambda s: (s.weight, s.team_registration.id))
-        group_stage_teams.sort(key=lambda s: (s.weight, s.team_registration.id))
-
-        for team in bracket_teams:
-            if team.stage == "Attente":
-                team.set_stage("Tableau")
-
-        for team in group_stage_teams:
-            if team.stage == "Attente":
                 team.set_stage("Poule")
-
+            elif team_reg.bracket_position is not None:
-        for team in waiting_teams:
+                team.set_stage("Tableau")
+            else:
                 team.set_stage("Attente")
 
-        if includeWaitingList is True:
+        # Sort teams based on tournament rules
-            final_teams = bracket_teams + group_stage_teams + waiting_teams
+        if self.team_sorting == TeamSortingType.INSCRIPTION_DATE:
-            # print(f"Final teams with waiting list: {len(final_teams)}")
+            complete_teams.sort(key=lambda t: (
+                t.registration_date is None,
+                t.registration_date or datetime.min,
+                t.initial_weight,
+                t.team_registration.id
+            ))
+            waiting_teams.sort(key=lambda t: (
+                t.registration_date is None,
+                t.registration_date or datetime.min,
+                t.initial_weight,
+                t.team_registration.id
+            ))
         else:
-            final_teams = bracket_teams + group_stage_teams
+            complete_teams.sort(key=lambda t: (t.initial_weight, t.team_registration.id))
-            # print(f"Final teams without waiting list: {len(final_teams)}")
+            waiting_teams.sort(key=lambda t: (t.initial_weight, t.team_registration.id))
-        return final_teams
+
+        # Determine final team list based on tournament settings
+        if len(complete_teams) <= self.team_count:
+            all_teams = wildcard_bracket + wildcard_group_stage + complete_teams
+            if include_waiting_list:
+                all_teams.extend(waiting_teams)
+            return all_teams
+
+        # Split teams into main bracket and waiting list
+        qualified_teams = complete_teams[:self.team_count]
+        excess_teams = complete_teams[self.team_count:]
+
+        # Combine all waiting list teams
+        waiting_list = excess_teams + waiting_teams
+
+        # Return final sorted list
+        if include_waiting_list:
+            return wildcard_bracket + wildcard_group_stage + qualified_teams + waiting_list
+        return wildcard_bracket + wildcard_group_stage + qualified_teams
 
 
     def match_groups(self, broadcasted, group_stage_id, round_id):

tournaments/templates/tournaments/team_stats.html

@@ -16,6 +16,18 @@
                 </div>
             </div>
 
+            <div class="match-result bottom-border">
+                <div class="player">
+                    <div class="semibold">
+                        <strong>Position initiale</strong>
+                    </div>
+                </div>
+                <div class="scores">
+                    <span class="score ws numbers">{{ stats.team_rank }} / {{ stats.total_teams }}</span>
+                </div>
+            </div>
+
+
             {% if stats.final_ranking %}
             <div class="match-result bottom-border">
                 <div class="player">