From d297a4c78a13c18902e46c7e9f839d8dddb0b29e Mon Sep 17 00:00:00 2001
From: Raz <razmig@staxriver.com>
Date: Wed, 12 Feb 2025 21:00:35 +0100
Subject: [PATCH 01/25] fix tournament info url detection and add format in
 match cells improve rankings broadcast screen

---
 tournaments/models/enums.py                   | 20 +++++++++++++++++++
 tournaments/models/match.py                   |  8 ++++++--
 tournaments/static/tournaments/css/style.css  | 10 ++++++++++
 .../broadcast/broadcasted_match.html          | 10 +++++++---
 .../broadcast/broadcasted_ranking.html        | 10 ++++++++--
 .../templates/tournaments/match_cell.html     | 10 ++++++----
 .../tournaments/tournament_info.html          |  3 ++-
 7 files changed, 59 insertions(+), 12 deletions(-)

diff --git a/tournaments/models/enums.py b/tournaments/models/enums.py
index 666aca2..c3f3be6 100644
--- a/tournaments/models/enums.py
+++ b/tournaments/models/enums.py
@@ -96,6 +96,26 @@ class FederalMatchCategory(models.IntegerChoices):
     SINGLE_SET_OF_FOUR_GAMES = 13, 'Single set of four games'
     SINGLE_SET_OF_FOUR_GAMES_DECISIVE_POINT = 14, 'Single set of four games with decisive point'
 
+    @property
+    def format_label_short(self):
+        format_mapping = {
+            self.TWO_SETS: "A1",
+            self.TWO_SETS_SUPER_TIE: "B1",
+            self.TWO_SETS_FOUR_GAME: "C1",
+            self.NINE_GAMES: "D1",
+            self.SUPER_TIE: "E",
+            self.TWO_SETS_OF_SUPER_TIE: "G",
+            self.MEGA_TIE: "F",
+            self.SINGLE_SET: "H1",
+            self.SINGLE_SET_DECISIVE_POINT: "H2",
+            self.TWO_SETS_DECISIVE_POINT: "A2",
+            self.TWO_SETS_DECISIVE_POINT_SUPER_TIE: "B2",
+            self.TWO_SETS_FOUR_GAME_DECISIVE_POINT: "C2",
+            self.NINE_GAMES_DECISIVE_POINT: "D2",
+            self.SINGLE_SET_OF_FOUR_GAMES: "I1"
+        }
+        return format_mapping.get(self, "")
+
     def last_set_is_tie_break(value):
         if value == FederalMatchCategory.TWO_SETS_FOUR_GAME or value == FederalMatchCategory.TWO_SETS_FOUR_GAME_DECISIVE_POINT or value == FederalMatchCategory.TWO_SETS_SUPER_TIE or value == FederalMatchCategory.SUPER_TIE or value == FederalMatchCategory.MEGA_TIE or value == FederalMatchCategory.TWO_SETS_DECISIVE_POINT_SUPER_TIE:
             return True
diff --git a/tournaments/models/match.py b/tournaments/models/match.py
index acdf519..b991533 100644
--- a/tournaments/models/match.py
+++ b/tournaments/models/match.py
@@ -318,7 +318,9 @@ class Match(models.Model):
             group_stage_name = self.group_stage.display_name()
 
         ended = self.end_date is not None
-        livematch = LiveMatch(title, date, time_indication, court, self.started(), ended, group_stage_name)
+        live_format = "Format " + FederalMatchCategory(self.format).format_label_short
+
+        livematch = LiveMatch(title, date, time_indication, court, self.started(), ended, group_stage_name, live_format)
 
         for team in self.live_teams():
             livematch.add_team(team)
@@ -369,7 +371,7 @@ class Team:
         }
 
 class LiveMatch:
-    def __init__(self, title, date, time_indication, court, started, ended, group_stage_name):
+    def __init__(self, title, date, time_indication, court, started, ended, group_stage_name, format):
         self.title = title
         self.date = date
         self.teams = []
@@ -379,6 +381,7 @@ class LiveMatch:
         self.ended = ended
         self.has_walk_out = False
         self.group_stage_name = group_stage_name
+        self.format = format
 
     def add_team(self, team):
         self.teams.append(team)
@@ -396,6 +399,7 @@ class LiveMatch:
             "ended": self.ended,
             "has_walk_out": self.has_walk_out,
             "group_stage_name": self.group_stage_name,
+            "format": self.format
         }
 
     def show_time_indication(self):
diff --git a/tournaments/static/tournaments/css/style.css b/tournaments/static/tournaments/css/style.css
index bbb3d49..6b28ce4 100644
--- a/tournaments/static/tournaments/css/style.css
+++ b/tournaments/static/tournaments/css/style.css
@@ -246,6 +246,7 @@ tr {
     font-family: "Anybody-ExtraBold";
     font-size: 1.2em;
     color: #1b223a;
+    line-height: 24px; /* Match the height of flex-row */
 }
 
 .title {
@@ -816,3 +817,12 @@ h-margin {
 .group-stage-link:hover {
     color: #f39200; /* Or whatever hover color you prefer */
 }
+
+.tournament-info a {
+    color: #f39200;
+    text-decoration: underline;
+    font-weight: bold;
+}
+.tournament-info a:hover {
+    color: #f39200;
+}
diff --git a/tournaments/templates/tournaments/broadcast/broadcasted_match.html b/tournaments/templates/tournaments/broadcast/broadcasted_match.html
index ef51dd8..9e3d0cc 100644
--- a/tournaments/templates/tournaments/broadcast/broadcasted_match.html
+++ b/tournaments/templates/tournaments/broadcast/broadcasted_match.html
@@ -2,9 +2,13 @@
 
      <div class="flex-row">
          <label class="left-label matchtitle">
-             <span x-text="match.group_stage_name"></span><span x-show="match.group_stage_name"> :</span> <span x-text="match.title"></span>
+             <span x-text="match.group_stage_name"></span>
+             <span x-show="match.group_stage_name"> :</span>
+             <span x-text="match.title"></span>
          </label>
-         <!-- <label class="right-label info"><span x-text="match.date"></span></label> -->
+         <label class="right-label minor-info bold" x-show="match.ended === false">
+                 <span x-text="match.court"></span>
+             </label>
      </div>
 
      <template x-for="i in match.teams.length">
@@ -59,7 +63,7 @@
 
      <div class="top-margin flex-row">
          <label class="left-label minor-info bold"><span x-text="match.time_indication"></span></label>
-         <label class="right-label minor-info semibold"><span x-text="match.court"></span></label>
+         <label class="right-label minor-info semibold"><span x-text="match.format"></span></label>
      </div>
 
  </div>
diff --git a/tournaments/templates/tournaments/broadcast/broadcasted_ranking.html b/tournaments/templates/tournaments/broadcast/broadcasted_ranking.html
index d64e467..5188f68 100644
--- a/tournaments/templates/tournaments/broadcast/broadcasted_ranking.html
+++ b/tournaments/templates/tournaments/broadcast/broadcasted_ranking.html
@@ -3,7 +3,11 @@
             <div>
                 <div class="table-row-3-colums-ranks">
 
-                    <div class="table-cell"><div class="mybox center"><span x-text="ranking.formatted_ranking"></div></div>
+                    <div class="table-cell">
+                                        <div class="mybox center">
+                                            <span style="font-size: 1.4em;" x-text="ranking.formatted_ranking"></span>
+                                        </div>
+                                    </div>
                     <div class="table-cell table-cell-large padding-left semibold">
 
                         <template x-for="name in ranking.names" >
@@ -11,7 +15,9 @@
                         </template>
                     </div>
                     {% if tournament.display_points_earned %}
-                    <div class="table-cell right horizontal-padding numbers"><span x-text="ranking.points"></div>
+                    <div class="table-cell right horizontal-padding numbers">
+                                        <span style="font-size: 1.4em;" x-text="ranking.points"></span>
+                                    </div>
                     {% endif %}
                 </div>
                 <div x-show="index < column.length - 1">
diff --git a/tournaments/templates/tournaments/match_cell.html b/tournaments/templates/tournaments/match_cell.html
index 2fc0928..fc0e17c 100644
--- a/tournaments/templates/tournaments/match_cell.html
+++ b/tournaments/templates/tournaments/match_cell.html
@@ -3,10 +3,12 @@
         <div class="cell medium-12 large-3 my-block">
             <div class="bubble">
 
-                <!-- <div class="flex-row"> -->
+                <div class="flex-row">
                     <label class="matchtitle">{{ match.title }}</label>
-                    <!-- <label class="right-label info">{{ match.date }}</label> -->
-                <!-- </div> -->
+                    {% if not match.ended %}
+                    <label class="right-label minor-info bold">{{ match.court }}</label>
+                    {% endif %}
+                </div>
 
                 <div>
 
@@ -62,7 +64,7 @@
                     </label>
                     <label class="right-label minor-info">
                         {% if not match.ended %}
-                        {{ match.court }}
+                        {{ match.format }}
                         {% endif %}
                     </label>
                     <!-- <a href="" class="right-label">{{ match.court }}</a> -->
diff --git a/tournaments/templates/tournaments/tournament_info.html b/tournaments/templates/tournaments/tournament_info.html
index 586f917..f54c34b 100644
--- a/tournaments/templates/tournaments/tournament_info.html
+++ b/tournaments/templates/tournaments/tournament_info.html
@@ -99,7 +99,8 @@
                 {% if tournament.information %}
                 <p>
                     <div class="semibold">Infos</div>
-                    <div>{{ tournament.information|linebreaksbr }}</div>
+                    <div class="tournament-info">
+                        {{ tournament.information|linebreaksbr|urlize }}</div>
                 </p>
                 {% endif %}
 

From b2b47dc93b85dfee9f54f856eccb2da40dcbdd8c Mon Sep 17 00:00:00 2001
From: Raz <razmig@staxriver.com>
Date: Thu, 13 Feb 2025 08:25:27 +0100
Subject: [PATCH 02/25] add some team stat

---
 tournaments/models/team_registration.py       |  40 +++-
 tournaments/models/tournament.py              | 192 ++++++++----------
 .../templates/tournaments/team_stats.html     |  12 ++
 3 files changed, 129 insertions(+), 115 deletions(-)

diff --git a/tournaments/models/team_registration.py b/tournaments/models/team_registration.py
index 1586883..5f17743 100644
--- a/tournaments/models/team_registration.py
+++ b/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
diff --git a/tournaments/models/tournament.py b/tournaments/models/tournament.py
index 8bed207..448bc8c 100644
--- a/tournaments/models/tournament.py
+++ b/tournaments/models/tournament.py
@@ -324,126 +324,94 @@ class Tournament(models.Model):
             print("else", index, self.team_count)
             return -1
 
-    def teams(self, includeWaitingList):
-        # print("Starting teams method")
-        bracket_teams = []
-        group_stage_teams = []
-        waiting_teams = []
-        teams = []
-        wildcard_bracket = []
-        wildcard_group_stage = []
-        complete_teams = []
-        closed_registration_date = self.closed_registration_date
-        # print(f"Closed registration date: {closed_registration_date}")
-
-        for team_registration in self.teamregistration_set.all():
-            # print(f"Processing team registration: {team_registration}")
-            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:
-                is_valid = True
-            if closed_registration_date is None:
-                is_valid = True
-            if team_registration.registration_date is None:
-                is_valid = True
-            # print(f"Is valid: {is_valid}")
-            if team_registration.out_of_tournament() is False:
-                team = TeamItem(team_registration)
-                # print(f"Created team: {team}")
-                if team_registration.group_stage_position is not None:
-                    team.set_stage("Poule")
-                elif team_registration.bracket_position is not None:
-                    team.set_stage("Tableau")
-                else:
-                    team.set_stage("Attente")
-                # print(f"Team stage: {team.stage}")
-
-                teams.append(team)
-                if team_registration.wild_card_bracket:
-                    wildcard_bracket.append(team)
-                elif team_registration.wild_card_group_stage:
-                    wildcard_group_stage.append(team)
-                elif is_valid is True:
-                    complete_teams.append(team)
-                else:
-                    waiting_teams.append(team)
-
-        # print(f"Total teams: {len(teams)}")
-        # print(f"Wildcard bracket: {len(wildcard_bracket)}")
-        # 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))
+    def teams(self, include_waiting_list):
+        """
+        Get sorted list of teams for the tournament.
 
-        selected_teams = complete_teams[:self.team_count]
-        selected_teams.sort(key=lambda s: (s.initial_weight, s.team_registration.id))
+        Args:
+            include_waiting_list (bool): Whether to include teams in waiting list
 
-        if seeds_count > 0:
-            bracket_teams = selected_teams[:seeds_count] + wildcard_bracket
-        else:
-            bracket_teams = []
-        # print(f"Bracket teams: {len(bracket_teams)}")
+        Returns:
+            list: List of TeamItem objects sorted according to tournament rules
+        """
+        # Initialize team categories
+        complete_teams = []
+        wildcard_bracket = []
+        wildcard_group_stage = []
+        waiting_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))
+        # Get registration cutoff date
+        closed_date = self.closed_registration_date
+
+        # Process each team registration
+        for team_reg in self.teamregistration_set.all():
+            if team_reg.out_of_tournament():
+                continue
+
+            # Create team item
+            team = TeamItem(team_reg)
+
+            # Determine if registration is valid based on date
+            is_valid = (
+                closed_date is None or
+                team_reg.registration_date is None or
+                (team_reg.registration_date and team_reg.registration_date <= closed_date)
+            )
+
+            # Categorize team
+            if team_reg.wild_card_bracket:
+                wildcard_bracket.append(team)
+            elif team_reg.wild_card_group_stage:
+                wildcard_group_stage.append(team)
+            elif is_valid:
+                complete_teams.append(team)
             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")
+                waiting_teams.append(team)
 
-        for team in group_stage_teams:
-            if team.stage == "Attente":
+            # Set initial stage
+            if team_reg.group_stage_position is not None:
                 team.set_stage("Poule")
+            elif team_reg.bracket_position is not None:
+                team.set_stage("Tableau")
+            else:
+                team.set_stage("Attente")
 
-        for team in waiting_teams:
-            team.set_stage("Attente")
-
-        if includeWaitingList is True:
-            final_teams = bracket_teams + group_stage_teams + waiting_teams
-            # print(f"Final teams with waiting list: {len(final_teams)}")
+        # Sort teams based on tournament rules
+        if self.team_sorting == TeamSortingType.INSCRIPTION_DATE:
+            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
-            # print(f"Final teams without waiting list: {len(final_teams)}")
-        return final_teams
+            complete_teams.sort(key=lambda t: (t.initial_weight, t.team_registration.id))
+            waiting_teams.sort(key=lambda t: (t.initial_weight, t.team_registration.id))
+
+        # 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):
diff --git a/tournaments/templates/tournaments/team_stats.html b/tournaments/templates/tournaments/team_stats.html
index fbd0061..e1a7d47 100644
--- a/tournaments/templates/tournaments/team_stats.html
+++ b/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">

From 2460861bc428b049a2d261f80679a5e1170bb83e Mon Sep 17 00:00:00 2001
From: Raz <razmig@staxriver.com>
Date: Thu, 13 Feb 2025 08:31:07 +0100
Subject: [PATCH 03/25] add some team stat

---
 tournaments/models/team_registration.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tournaments/models/team_registration.py b/tournaments/models/team_registration.py
index 5f17743..22f70ef 100644
--- a/tournaments/models/team_registration.py
+++ b/tournaments/models/team_registration.py
@@ -226,7 +226,7 @@ class TeamRegistration(models.Model):
             sign = "+"
         if team_rank == self.final_ranking:
             sign = ""
-        return f" ({sign}"+f"{team_rank})"
+        return f" ({sign}"+f"{abs(self.final_ranking - team_rank)})"
 
     def get_points_earned(self):
         return self.points_earned

From 57d41ae10f3790082871da7712499465bf62d8c3 Mon Sep 17 00:00:00 2001
From: Raz <razmig@staxriver.com>
Date: Thu, 13 Feb 2025 08:33:11 +0100
Subject: [PATCH 04/25] add some team stat

---
 tournaments/models/team_registration.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tournaments/models/team_registration.py b/tournaments/models/team_registration.py
index 22f70ef..656572f 100644
--- a/tournaments/models/team_registration.py
+++ b/tournaments/models/team_registration.py
@@ -212,7 +212,7 @@ class TeamRegistration(models.Model):
     def get_final_ranking(self):
         if self.final_ranking:
             if self.final_ranking == 1:
-                return "1er"
+                return "1er" + self.ranking_delta()
             return f"{self.final_ranking}ème" + self.ranking_delta()
         return None
 

From 935547c44de0e1363c88832ff11c6a3f1d52c56d Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Thu, 13 Feb 2025 12:33:47 +0100
Subject: [PATCH 05/25] Adds the last participation if the last created event
 was not find

---
 tournaments/models/custom_user.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tournaments/models/custom_user.py b/tournaments/models/custom_user.py
index befa50d..c77bc62 100644
--- a/tournaments/models/custom_user.py
+++ b/tournaments/models/custom_user.py
@@ -1,4 +1,5 @@
 from django.db import models
+from django.apps import apps
 from django.contrib.auth.models import AbstractUser
 from . import club, enums
 import uuid
@@ -63,4 +64,12 @@ class CustomUser(AbstractUser):
         latest_event = self.event_set.order_by('-creation_date').first()
         if latest_event and latest_event.club:
             return latest_event.club.name
+        if self.licence_id:
+            PlayerRegistration = apps.get_model('tournaments', 'PlayerRegistration')
+            player_registration = PlayerRegistration.objects.filter(licence_id=self.licence_id).order_by('team_registration__registration_date').first()
+            try:
+                return player_registration.team_registration.tournament.event.club.name
+            except AttributeError:
+                return None
+
         return None

From e07c473ba3f7456e56540853c4d361b4c5c31ab7 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Thu, 13 Feb 2025 12:37:03 +0100
Subject: [PATCH 06/25] Add filter for registered_online in PlayerRegistration

---
 tournaments/admin.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tournaments/admin.py b/tournaments/admin.py
index 61e8cdf..9b19ac0 100644
--- a/tournaments/admin.py
+++ b/tournaments/admin.py
@@ -71,7 +71,7 @@ class RoundAdmin(admin.ModelAdmin):
 class PlayerRegistrationAdmin(admin.ModelAdmin):
     list_display = ['first_name', 'last_name', 'licence_id', 'rank']
     search_fields = ('first_name', 'last_name')
-    list_filter = [TeamScoreTournamentListFilter]
+    list_filter = ['registered_online', TeamScoreTournamentListFilter]
     ordering = ['last_name', 'first_name']
 
 class MatchAdmin(admin.ModelAdmin):

From 6ff1518aeea90807e6811099feaae154cae41743 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Thu, 13 Feb 2025 16:58:02 +0100
Subject: [PATCH 07/25] adds required version file

---
 tournaments/static/misc/required-version.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 tournaments/static/misc/required-version.txt

diff --git a/tournaments/static/misc/required-version.txt b/tournaments/static/misc/required-version.txt
new file mode 100644
index 0000000..49d5957
--- /dev/null
+++ b/tournaments/static/misc/required-version.txt
@@ -0,0 +1 @@
+0.1

From 220d4fa7e63221de9af0796f8132bf8013f4624f Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Fri, 14 Feb 2025 10:18:15 +0100
Subject: [PATCH 08/25] Adds date range tournament filter

---
 tournaments/admin.py   |  4 ++--
 tournaments/filters.py | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/tournaments/admin.py b/tournaments/admin.py
index 9b19ac0..25ee57c 100644
--- a/tournaments/admin.py
+++ b/tournaments/admin.py
@@ -12,7 +12,7 @@ from django.contrib.auth.forms import UserCreationForm, UserChangeForm
 
 from .forms import CustomUserCreationForm, CustomUserChangeForm
 
-from .filters import TeamScoreTournamentListFilter, MatchTournamentListFilter, SimpleTournamentListFilter, MatchTypeListFilter, SimpleIndexListFilter
+from .filters import TeamScoreTournamentListFilter, MatchTournamentListFilter, SimpleTournamentListFilter, MatchTypeListFilter, SimpleIndexListFilter, StartDateRangeFilter
 
 
 class CustomUserAdmin(UserAdmin):
@@ -48,7 +48,7 @@ class EventAdmin(admin.ModelAdmin):
 
 class TournamentAdmin(admin.ModelAdmin):
     list_display = ['display_name', 'event', 'is_private', 'start_date', 'payment', 'creator']
-    list_filter = ['is_deleted', 'event__creator']
+    list_filter = [StartDateRangeFilter, 'is_deleted', 'event__creator']
     ordering = ['-start_date']
     search_fields = ['id']
 
diff --git a/tournaments/filters.py b/tournaments/filters.py
index 167915f..1b841e6 100644
--- a/tournaments/filters.py
+++ b/tournaments/filters.py
@@ -2,6 +2,8 @@ from django.contrib import admin
 from .models import Club, TeamScore, Tournament, CustomUser, Event, Round, GroupStage, Match, TeamRegistration, PlayerRegistration, Purchase, Court, DateInterval, FailedApiCall
 from django.db.models import Q
 from django.utils.translation import gettext_lazy as _
+from django.utils import timezone
+from datetime import timedelta
 import uuid
 from enum import Enum
 
@@ -101,3 +103,36 @@ class SimpleIndexListFilter(admin.SimpleListFilter):
             return queryset.filter(index=self.value())
         else:
             return queryset
+
+class StartDateRangeFilter(admin.SimpleListFilter):
+    title = 'tournament time range'  # displayed in the admin UI
+    parameter_name = 'date_range'    # URL parameter
+
+    def lookups(self, request, model_admin):
+        return (
+            ('upcoming', 'Next 30 days'),
+            ('recent', 'Last 30 days'),
+            ('current', 'Current (±3 days)'),
+        )
+
+    def queryset(self, request, queryset):
+        if not self.value():
+            return queryset
+
+        today = timezone.now().date()
+
+        if self.value() == 'upcoming':
+            return queryset.filter(
+                start_date__gte=today,
+                start_date__lte=today + timedelta(days=30)
+            )
+        elif self.value() == 'recent':
+            return queryset.filter(
+                start_date__gte=today - timedelta(days=30),
+                start_date__lte=today
+            )
+        elif self.value() == 'current':
+            return queryset.filter(
+                start_date__gte=today - timedelta(days=3),
+                start_date__lte=today + timedelta(days=3)
+            )

From eb7b33acf6a6225172b627cf3a7284eb3f94b870 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Fri, 14 Feb 2025 11:46:49 +0100
Subject: [PATCH 09/25] change download button style

---
 tournaments/static/tournaments/css/style.css | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tournaments/static/tournaments/css/style.css b/tournaments/static/tournaments/css/style.css
index 6b28ce4..a112a8b 100644
--- a/tournaments/static/tournaments/css/style.css
+++ b/tournaments/static/tournaments/css/style.css
@@ -777,9 +777,9 @@ h-margin {
 }
 .download-button {
     margin-right: 6px;
-    color: #1a223a;
+    color: #fff7ed;
     padding: 8px 12px;
-    background-color: white;
+    background-color: #1a223a;
     border-radius: 12px;
     text-decoration: none;
     font-size: 12px;
@@ -787,7 +787,7 @@ h-margin {
 }
 
 .download-button:hover {
-    color: orange;
+    color: #f39200;
 }
 
 .match-result a {

From 508fd8ea31e7a29a13f9caf3ca8ca5a354b767a2 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Fri, 14 Feb 2025 21:29:09 +0100
Subject: [PATCH 10/25] Adds registration date to TeamReg admin

---
 tournaments/admin.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tournaments/admin.py b/tournaments/admin.py
index 25ee57c..e05e93f 100644
--- a/tournaments/admin.py
+++ b/tournaments/admin.py
@@ -53,7 +53,7 @@ class TournamentAdmin(admin.ModelAdmin):
     search_fields = ['id']
 
 class TeamRegistrationAdmin(admin.ModelAdmin):
-    list_display = ['player_names', 'group_stage_position', 'name', 'tournament']
+    list_display = ['player_names', 'group_stage_position', 'name', 'tournament', 'registration_date']
     list_filter = [SimpleTournamentListFilter]
     search_fields = ['id']
 

From 193ca2c0436c972cb2bc8997df6e75ad02715f6e Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Fri, 14 Feb 2025 22:16:26 +0100
Subject: [PATCH 11/25] fix tournament import

---
 tournaments/views.py | 35 ++++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/tournaments/views.py b/tournaments/views.py
index c893323..343acb8 100644
--- a/tournaments/views.py
+++ b/tournaments/views.py
@@ -792,26 +792,27 @@ def tournament_import_view(request):
                 with zipfile.ZipFile(zip_file) as z:
                     # First, process rounds
                     rounds_data = get_file_data(z, f"{tournament_id}/rounds.json")
+                    rounds_data = get_file_data(z, f"{tournament_id}/rounds.json")
                     if rounds_data:
-                        # First pass: Create rounds without parent relationships
-                        rounds_without_parent = []
+                        # First pass: Create rounds with preserved UUIDs
                         for item in rounds_data:
                             item['tournament'] = tournament.id
-                            # Temporarily remove parent field
-                            parent = item.pop('parent', None)
-                            rounds_without_parent.append({'data': item, 'parent': parent})
-
-                        serializer = RoundSerializer(data=[item['data'] for item in rounds_without_parent], many=True)
-                        serializer.is_valid(raise_exception=True)
-                        created_rounds = serializer.save()
-
-                        # Create a mapping of round IDs
-                        round_mapping = {round_obj.id: round_obj for round_obj in created_rounds}
-
-                        # Second pass: Update parent relationships
-                        for round_obj, original_data in zip(created_rounds, rounds_without_parent):
-                            if original_data['parent']:
-                                round_obj.parent = round_mapping.get(original_data['parent'])
+                            round_id = item['id']  # Preserve the original UUID
+                            Round.objects.create(
+                                id=round_id,
+                                tournament_id=tournament.id,
+                                index=item['index'],
+                                format=item.get('format'),
+                                start_date=item.get('start_date'),
+                                group_stage_loser_bracket=item.get('group_stage_loser_bracket', False),
+                                loser_bracket_mode=item.get('loser_bracket_mode', 0)
+                            )
+
+                        # Second pass: Set parent relationships
+                        for item in rounds_data:
+                            if item.get('parent'):
+                                round_obj = Round.objects.get(id=item['id'])
+                                round_obj.parent_id = item['parent']
                                 round_obj.save()
 
                     # Then process all other files

From 05f04655847aacb2f065c3edb897f93cb5e9fcd7 Mon Sep 17 00:00:00 2001
From: Raz <razmig@staxriver.com>
Date: Sun, 16 Feb 2025 11:33:35 +0100
Subject: [PATCH 12/25] optimize code using count() in place of len() and
 displays unfinished tournament that should be over

---
 tournaments/models/club.py              |  2 +-
 tournaments/models/custom_user.py       |  2 +-
 tournaments/models/match.py             |  6 +++---
 tournaments/models/team_registration.py |  2 +-
 tournaments/models/tournament.py        | 22 +++++++++++++++-------
 tournaments/views.py                    |  4 ++--
 6 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/tournaments/models/club.py b/tournaments/models/club.py
index 0d62c18..e79889f 100644
--- a/tournaments/models/club.py
+++ b/tournaments/models/club.py
@@ -28,7 +28,7 @@ class Club(models.Model):
         return self.name
 
     def events_count(self):
-        return len(self.event_set.all())
+        return self.event_set.count()
 
     def court_name(self, index):
         for court in self.court_set.all():
diff --git a/tournaments/models/custom_user.py b/tournaments/models/custom_user.py
index c77bc62..4a5d2ad 100644
--- a/tournaments/models/custom_user.py
+++ b/tournaments/models/custom_user.py
@@ -55,7 +55,7 @@ class CustomUser(AbstractUser):
         return f"{self.username} : {self.first_name} {self.last_name} | {self.email} | {self.phone}"
 
     def event_count(self):
-        return len(self.event_set.all())
+        return self.event_set.count()
 
     def full_name(self):
         return f"{self.first_name} {self.last_name}"
diff --git a/tournaments/models/match.py b/tournaments/models/match.py
index b991533..2c49b75 100644
--- a/tournaments/models/match.py
+++ b/tournaments/models/match.py
@@ -85,7 +85,7 @@ class Match(models.Model):
         previous_index = self.round.index + 1
 
         # Check if the next index is within the bounds of the rounds array
-        if previous_index < len(self.round.tournament.round_set.all()):
+        if previous_index < self.round.tournament.round_set.count():
             return self.round.tournament.round_set.filter(index=previous_index, parent = None).first()
 
         # Return None or an appropriate value if the index is out of bounds
@@ -148,7 +148,7 @@ class Match(models.Model):
         previous_top_match = self.precedent_match(True)
         previous_bottom_match = self.precedent_match(False)
         if len(team_scores) == 0:
-            if (self.round and len(self.round.tournament.round_set.all()) == self.round.index -1):
+            if (self.round and self.round.tournament.round_set.count() == self.round.index -1):
                 return teams
             if (self.group_stage):
                 return teams
@@ -280,7 +280,7 @@ class Match(models.Model):
     def should_appear(self):
         if self.disabled is True:
             return False
-        return len(self.team_scores.all()) > 0
+        return self.team_scores.count() > 0
 
         # elif self.group_stage is None:
         #     if len(self.team_scores.all()) == 2:
diff --git a/tournaments/models/team_registration.py b/tournaments/models/team_registration.py
index 656572f..2bc141a 100644
--- a/tournaments/models/team_registration.py
+++ b/tournaments/models/team_registration.py
@@ -109,7 +109,7 @@ class TeamRegistration(models.Model):
         self.save()  # Save the updated weight if necessary
 
     def is_valid_for_summon(self):
-        return len(self.playerregistration_set.all()) > 0 or self.name is not None
+        return self.playerregistration_set.count() > 0 or self.name is not None
 
     def initial_weight(self):
         if self.locked_weight is None:
diff --git a/tournaments/models/tournament.py b/tournaments/models/tournament.py
index 448bc8c..2abebf7 100644
--- a/tournaments/models/tournament.py
+++ b/tournaments/models/tournament.py
@@ -215,7 +215,7 @@ class Tournament(models.Model):
                 return "Annulé"
 
             teams = self.teams(True)
-            if self.supposedly_in_progress() or self.end_date is not None:
+            if self.supposedly_in_progress() or self.end_date is not None or self.should_be_over():
                 teams = [t for t in teams if t.stage != "Attente"]
                 if teams is not None and len(teams) > 0:
                     word = "équipe"
@@ -614,7 +614,7 @@ class Tournament(models.Model):
         matches = []
         group_stages = []
 
-        if len(self.groupstage_set.all()) > 0 and self.no_bracket_match_has_started():
+        if self.groupstage_set.count() > 0 and self.no_bracket_match_has_started():
             group_stages = [gs.live_group_stages() for gs in self.last_group_stage_step()]
             matches = self.broadcasted_group_stages_matches()
             first_round = self.first_round()
@@ -798,7 +798,7 @@ class Tournament(models.Model):
         return False
 
     def has_team_registrations(self):
-        return len(self.teamregistration_set.all()) > 0
+        return self.teamregistration_set.count() > 0
 
     def display_summons(self):
         if self.end_date is not None:
@@ -893,6 +893,14 @@ class Tournament(models.Model):
 
         return start <= now <= end
 
+    def should_be_over(self):
+        if self.end_date is not None:
+            return True
+
+        timezoned_datetime = timezone.localtime(self.start_date)
+        end = timezoned_datetime + timedelta(days=self.day_duration + 1)
+        now = timezone.now()
+        return now >= end and self.is_build_and_not_empty()
 
     def display_points_earned(self):
         return self.federal_level_category != FederalLevelCategory.UNLISTED and self.hide_points_earned is False
@@ -901,7 +909,7 @@ class Tournament(models.Model):
         return self.hide_teams_weight
 
     def is_build_and_not_empty(self):
-        return (len(self.groupstage_set.all()) > 0 or len(self.round_set.all()) > 0) and len(self.teamregistration_set.all()) >= 4
+        return self.groupstage_set.count() > 0 or self.round_set.count() > 0 and self.teamregistration_set.count() >= 4
 
     def day_duration_formatted(self):
         return plural_format("jour", self.day_duration)
@@ -983,7 +991,7 @@ class Tournament(models.Model):
 
         # Check target team count and waiting list limit
         if self.team_count is not None:
-            current_team_count = len([tr for tr in self.teamregistration_set.all() if tr.out_of_tournament() is False])
+            current_team_count = self.teamregistration_set.exclude(walk_out=True).count()
             if current_team_count >= self.team_count:
                 if self.waiting_list_limit is not None:
                     waiting_list_count = current_team_count - self.team_count
@@ -1013,7 +1021,7 @@ class Tournament(models.Model):
 
             if self.team_count is not None:
                 # Get all team registrations excluding walk_outs
-                current_team_count = len([tr for tr in self.teamregistration_set.all() if tr.out_of_tournament() is False])
+                current_team_count = self.teamregistration_set.exclude(walk_out=True).count()
                 if current_team_count >= self.team_count:
                     if self.waiting_list_limit is not None:
                         waiting_list_count = current_team_count - self.team_count
@@ -1048,7 +1056,7 @@ class Tournament(models.Model):
             return -1
 
         # Get count of active teams (not walked out)
-        current_team_count = len([tr for tr in self.teamregistration_set.all() if tr.out_of_tournament() is False])
+        current_team_count = self.teamregistration_set.exclude(walk_out=True).count()
 
         # If current count is less than target count, next team is not in waiting list
         if current_team_count < self.team_count:
diff --git a/tournaments/views.py b/tournaments/views.py
index 343acb8..ab49b00 100644
--- a/tournaments/views.py
+++ b/tournaments/views.py
@@ -141,8 +141,8 @@ def tournaments_query(query, club_id, ascending):
     return Tournament.objects.filter(*queries).order_by(sortkey)
 
 def finished_tournaments(club_id):
-    ended_tournaments = tournaments_query(Q(end_date__isnull=False), club_id, False)
-    return [t for t in ended_tournaments if t.display_tournament()]
+    ended_tournaments = tournaments_query(Q(is_private=False, is_deleted=False, event__club__isnull=False), club_id, False)
+    return [t for t in ended_tournaments if t.display_tournament() and t.should_be_over()]
 
 def live_tournaments(club_id):
     tournaments = tournaments_query(Q(end_date__isnull=True), club_id, True)

From 19eb5030c68696b90b7592dfc9427f764de828a3 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Mon, 17 Feb 2025 12:39:21 +0100
Subject: [PATCH 13/25] user exports

---
 tournaments/views.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/tournaments/views.py b/tournaments/views.py
index 343acb8..57f621b 100644
--- a/tournaments/views.py
+++ b/tournaments/views.py
@@ -890,10 +890,7 @@ def team_details(request, tournament_id, team_id):
 
 class UserListExportView(LoginRequiredMixin, View):
     def get(self, request, *args, **kwargs):
-        # Get users, excluding those with origin=UserOrigin.SITE, ordered by date_joined
-        users = CustomUser.objects.exclude(
-            origin=UserOrigin.SITE
-        ).order_by('date_joined')
+        users = CustomUser.objects.order_by('date_joined')
 
         # Prepare the response
         response = HttpResponse(content_type='text/plain; charset=utf-8')
@@ -901,7 +898,7 @@ class UserListExportView(LoginRequiredMixin, View):
         # Write header
         headers = [
             'Prenom', 'Nom', 'Club', 'Email', 'Telephone',
-            'Login', 'Actif', 'Inscription', 'Tournois'
+            'origine', 'Actif', 'Inscription', 'Tournois'
         ]
         response.write('\t'.join(headers) + '\n')
 
@@ -913,7 +910,7 @@ class UserListExportView(LoginRequiredMixin, View):
                 str(user.latest_event_club_name() or ''),
                 str(user.email or ''),
                 str(user.phone or ''),
-                str(user.username or ''),
+                str(user.get_origin_display()),
                 'Oui' if user.is_active else 'Non',
                 user.date_joined.strftime('%Y-%m-%d %H:%M:%S'),
                 str(user.event_count())

From eaad243c90f214ea54c01a31b992847020f1fa0b Mon Sep 17 00:00:00 2001
From: Raz <razmig@staxriver.com>
Date: Mon, 17 Feb 2025 13:43:15 +0100
Subject: [PATCH 14/25] improve should be over tournament setup

---
 tournaments/models/match.py      |  3 +++
 tournaments/models/tournament.py | 23 ++++++++++++++++++++++-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/tournaments/models/match.py b/tournaments/models/match.py
index 2c49b75..17d29a8 100644
--- a/tournaments/models/match.py
+++ b/tournaments/models/match.py
@@ -137,6 +137,9 @@ class Match(models.Model):
         team = Team(None, image, names, scores, weight, is_winner, walk_out)
         return team
 
+    def is_ready(self):
+        return self.team_scores.count() == 2
+
     def live_teams(self):
         #print('player names from match')
         ##return map(lambda ts: ts.player_names(), self.team_scores.all())
diff --git a/tournaments/models/tournament.py b/tournaments/models/tournament.py
index 2abebf7..9d8ba06 100644
--- a/tournaments/models/tournament.py
+++ b/tournaments/models/tournament.py
@@ -900,7 +900,28 @@ class Tournament(models.Model):
         timezoned_datetime = timezone.localtime(self.start_date)
         end = timezoned_datetime + timedelta(days=self.day_duration + 1)
         now = timezone.now()
-        return now >= end and self.is_build_and_not_empty()
+        return now >= end and self.is_build_and_not_empty() and self.nearly_over()
+
+    def nearly_over(self):
+        # First check group stages if they exist
+        if self.groupstage_set.count() > 0:
+            # Check if all group stages are completed
+            for group_stage in self.groupstage_set.all():
+                if group_stage.is_completed():
+                    return True
+
+        # If no group stages, check semi-finals
+        if self.round_set.count() > 0:
+            # Get round with index 1 (semi-finals) and no parent
+            semifinals = self.round_set.filter(index=1, parent=None).first()
+            if semifinals:
+                # Check if any match in semi-finals has started
+                for match in semifinals.match_set.all():
+                    if match.start_date is not None and match.is_ready():
+                        return True
+            return False
+
+        return False
 
     def display_points_earned(self):
         return self.federal_level_category != FederalLevelCategory.UNLISTED and self.hide_points_earned is False

From 6eee5c48d2f81b80c272620fcd18e11cad160c6d Mon Sep 17 00:00:00 2001
From: Raz <razmig@staxriver.com>
Date: Mon, 17 Feb 2025 13:46:15 +0100
Subject: [PATCH 15/25] improve should be over tournament setup

---
 tournaments/models/group_stage.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tournaments/models/group_stage.py b/tournaments/models/group_stage.py
index 16a4d95..b1a6488 100644
--- a/tournaments/models/group_stage.py
+++ b/tournaments/models/group_stage.py
@@ -140,7 +140,7 @@ class GroupStage(models.Model):
         return False
 
     def is_completed(self):
-        return not self.match_set.filter(end_date__isnull=True).exists()
+        return not self.match_set.filter(end_date__isnull=True).exists() and self.match_set.count() > 0
 
 class LiveGroupStage:
     def __init__(self, title, step, index):

From dec2d98ca1bbfdf3cdc711e6a649ed7b5f8c6ce0 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Tue, 18 Feb 2025 11:11:08 +0100
Subject: [PATCH 16/25] Adds username column

---
 tournaments/views.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tournaments/views.py b/tournaments/views.py
index e37ad77..5f847c5 100644
--- a/tournaments/views.py
+++ b/tournaments/views.py
@@ -897,8 +897,8 @@ class UserListExportView(LoginRequiredMixin, View):
 
         # Write header
         headers = [
-            'Prenom', 'Nom', 'Club', 'Email', 'Telephone',
-            'origine', 'Actif', 'Inscription', 'Tournois'
+            'Prenom', 'Nom', 'Club', 'Email', 'Telephone', 'Username',
+            'Origine', 'Actif', 'Inscription', 'Tournois'
         ]
         response.write('\t'.join(headers) + '\n')
 
@@ -910,6 +910,7 @@ class UserListExportView(LoginRequiredMixin, View):
                 str(user.latest_event_club_name() or ''),
                 str(user.email or ''),
                 str(user.phone or ''),
+                user.username,
                 str(user.get_origin_display()),
                 'Oui' if user.is_active else 'Non',
                 user.date_joined.strftime('%Y-%m-%d %H:%M:%S'),

From d587f301043259cfbeb433819cce1aedcb89c5d0 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Tue, 18 Feb 2025 11:25:33 +0100
Subject: [PATCH 17/25] add fields to the PlayerRegistration search

---
 tournaments/admin.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tournaments/admin.py b/tournaments/admin.py
index e05e93f..e93fdfc 100644
--- a/tournaments/admin.py
+++ b/tournaments/admin.py
@@ -60,7 +60,7 @@ class TeamRegistrationAdmin(admin.ModelAdmin):
 class TeamScoreAdmin(admin.ModelAdmin):
     list_display = ['team_registration', 'score', 'walk_out', 'match']
     list_filter = [TeamScoreTournamentListFilter]
-    search_fields = ['id']
+    search_fields = ['id', 'licence_id', 'first_name', 'last_name']
 
 class RoundAdmin(admin.ModelAdmin):
     list_display = ['tournament', 'name', 'index', 'parent']

From 5dd2ec63eda4a948a96e8059358acbca489002a9 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Tue, 18 Feb 2025 11:32:50 +0100
Subject: [PATCH 18/25] Add contain for licence_id search

---
 tournaments/admin.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tournaments/admin.py b/tournaments/admin.py
index e93fdfc..4678f32 100644
--- a/tournaments/admin.py
+++ b/tournaments/admin.py
@@ -60,7 +60,7 @@ class TeamRegistrationAdmin(admin.ModelAdmin):
 class TeamScoreAdmin(admin.ModelAdmin):
     list_display = ['team_registration', 'score', 'walk_out', 'match']
     list_filter = [TeamScoreTournamentListFilter]
-    search_fields = ['id', 'licence_id', 'first_name', 'last_name']
+    search_fields = ['id']
 
 class RoundAdmin(admin.ModelAdmin):
     list_display = ['tournament', 'name', 'index', 'parent']
@@ -70,7 +70,7 @@ class RoundAdmin(admin.ModelAdmin):
 
 class PlayerRegistrationAdmin(admin.ModelAdmin):
     list_display = ['first_name', 'last_name', 'licence_id', 'rank']
-    search_fields = ('first_name', 'last_name')
+    search_fields = ('first_name', 'last_name', 'licence_id__icontains')
     list_filter = ['registered_online', TeamScoreTournamentListFilter]
     ordering = ['last_name', 'first_name']
 

From eee120a78976941a1010c435cf8992e13f75b184 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Tue, 18 Feb 2025 12:04:00 +0100
Subject: [PATCH 19/25] test apns

---
 tournaments/views.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tournaments/views.py b/tournaments/views.py
index 5f847c5..c7d69ca 100644
--- a/tournaments/views.py
+++ b/tournaments/views.py
@@ -499,9 +499,12 @@ def download(request):
     return render(request, 'tournaments/download.html')
 
 def test_apns(request):
-    token = DeviceToken.objects.first()
 
-    asyncio.run(send_push_notification(token.value, 'hello!'))
+    user = CustomUser.objects.filter(username='razmig').first()
+    for device_token in user.devicetoken_set.all():
+        asyncio.run(send_push_notification(device_token.value, 'LOL?!'))
+
+    # token = DeviceToken.objects.first()
 
     return HttpResponse('OK!')
 

From 88920886b6947c04400a80fba50b61a96f197cf4 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Tue, 18 Feb 2025 12:09:12 +0100
Subject: [PATCH 20/25] test apns 2

---
 requirements.txt     | 1 +
 tournaments/views.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index a6a3e65..aa6fcb7 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -11,3 +11,4 @@ pandas==2.2.2
 xlrd==2.0.1
 openpyxl==3.1.5
 django-filter==24.3
+cryptography==41.0.7
diff --git a/tournaments/views.py b/tournaments/views.py
index c7d69ca..ae0cbb0 100644
--- a/tournaments/views.py
+++ b/tournaments/views.py
@@ -500,7 +500,7 @@ def download(request):
 
 def test_apns(request):
 
-    user = CustomUser.objects.filter(username='razmig').first()
+    user = CustomUser.objects.filter(username='laurent').first()
     for device_token in user.devicetoken_set.all():
         asyncio.run(send_push_notification(device_token.value, 'LOL?!'))
 

From 24b13744a8db6bfb43842ea9cb3e2b0019c640e5 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Tue, 18 Feb 2025 14:40:25 +0100
Subject: [PATCH 21/25] Adds user filter for DeviceToken

---
 tournaments/admin.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tournaments/admin.py b/tournaments/admin.py
index 4678f32..87dd2c2 100644
--- a/tournaments/admin.py
+++ b/tournaments/admin.py
@@ -111,6 +111,7 @@ class LogAdmin(admin.ModelAdmin):
 
 class DeviceTokenAdmin(admin.ModelAdmin):
     list_display = ['user', 'value']
+    list_filter = ['user']
 
 class DrawLogAdmin(admin.ModelAdmin):
     list_display = ['tournament', 'draw_date', 'draw_seed', 'draw_match_index', 'draw_team_position']

From ea1ce89f285c1be29e67f688d688fe295056d54b Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Tue, 18 Feb 2025 15:12:49 +0100
Subject: [PATCH 22/25] test for apns

---
 tournaments/views.py | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/tournaments/views.py b/tournaments/views.py
index ae0cbb0..6d40c4e 100644
--- a/tournaments/views.py
+++ b/tournaments/views.py
@@ -498,15 +498,26 @@ def club_broadcast_auto(request, broadcast_code):
 def download(request):
     return render(request, 'tournaments/download.html')
 
+import jwt
+import cryptography
+import httpx
+from django.http import JsonResponse
+
 def test_apns(request):
 
-    user = CustomUser.objects.filter(username='laurent').first()
-    for device_token in user.devicetoken_set.all():
-        asyncio.run(send_push_notification(device_token.value, 'LOL?!'))
+    return JsonResponse({
+            "jwt_version": jwt.__version__,
+            "cryptography_version": cryptography.__version__,
+            "httpx_version": httpx.__version__
+        })
+
+    # user = CustomUser.objects.filter(username='laurent').first()
+    # for device_token in user.devicetoken_set.all():
+    #     asyncio.run(send_push_notification(device_token.value, 'LOL?!'))
 
-    # token = DeviceToken.objects.first()
+    # # token = DeviceToken.objects.first()
 
-    return HttpResponse('OK!')
+    # return HttpResponse('OK!')
 
 def test_websocket(request):
     return render(request, 'tournaments/test_websocket.html')

From ecd33197a217c31995ef42a2786db6984e2d43b5 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Tue, 18 Feb 2025 15:16:48 +0100
Subject: [PATCH 23/25] revert

---
 tournaments/views.py | 21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

diff --git a/tournaments/views.py b/tournaments/views.py
index 6d40c4e..ae0cbb0 100644
--- a/tournaments/views.py
+++ b/tournaments/views.py
@@ -498,26 +498,15 @@ def club_broadcast_auto(request, broadcast_code):
 def download(request):
     return render(request, 'tournaments/download.html')
 
-import jwt
-import cryptography
-import httpx
-from django.http import JsonResponse
-
 def test_apns(request):
 
-    return JsonResponse({
-            "jwt_version": jwt.__version__,
-            "cryptography_version": cryptography.__version__,
-            "httpx_version": httpx.__version__
-        })
-
-    # user = CustomUser.objects.filter(username='laurent').first()
-    # for device_token in user.devicetoken_set.all():
-    #     asyncio.run(send_push_notification(device_token.value, 'LOL?!'))
+    user = CustomUser.objects.filter(username='laurent').first()
+    for device_token in user.devicetoken_set.all():
+        asyncio.run(send_push_notification(device_token.value, 'LOL?!'))
 
-    # # token = DeviceToken.objects.first()
+    # token = DeviceToken.objects.first()
 
-    # return HttpResponse('OK!')
+    return HttpResponse('OK!')
 
 def test_websocket(request):
     return render(request, 'tournaments/test_websocket.html')

From 5013342c83c0ecded55fc6f8168a6004618fe7c2 Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Wed, 19 Feb 2025 09:35:51 +0100
Subject: [PATCH 24/25] stop sending discord errors

---
 tournaments/signals.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tournaments/signals.py b/tournaments/signals.py
index 321fde0..848dbca 100644
--- a/tournaments/signals.py
+++ b/tournaments/signals.py
@@ -53,11 +53,11 @@ def send_discord_message(webhook_url, content):
     data = {
         "content": content
     }
-    response = requests.post(webhook_url, json=data)
-    if response.status_code != 204:
-        raise ValueError(
-            f'Error sending message to Discord webhook: {response.status_code}, {response.text}'
-        )
+    requests.post(webhook_url, json=data)
+    # if response.status_code != 204:
+    #     raise ValueError(
+    #         f'Error sending message to Discord webhook: {response.status_code}, {response.text}'
+    #     )
 
 @receiver(pre_delete, sender=TeamRegistration)
 def unregister_team(sender, instance, **kwargs):

From d0de8bfb9b3a279519667f3c56478af9ab116cdc Mon Sep 17 00:00:00 2001
From: Laurent <laurent@staxriver.com>
Date: Wed, 19 Feb 2025 10:02:34 +0100
Subject: [PATCH 25/25] Fix crash

---
 tournaments/models/tournament.py | 33 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/tournaments/models/tournament.py b/tournaments/models/tournament.py
index 9d8ba06..10f59f3 100644
--- a/tournaments/models/tournament.py
+++ b/tournaments/models/tournament.py
@@ -704,25 +704,24 @@ class Tournament(models.Model):
 
         # all started matches have ended, possibly
         last_finished_match = self.last_finished_match()
-
-        round = last_finished_match.round
-        if round is None: # when the last finished match is in the group stage
-            round = self.round_set.filter(parent__isnull=True).order_by('-index').first()
-
-        if round:
-            # print(f'last_finished_match = {last_finished_match.name}')
-            round_root_index = round.root_round().index
-            # print(f'round_index = {round_root_index}')
-            if round_root_index == 0:
-                return round
-            else:
-                round = self.round_set.filter(parent=None,index=round_root_index-1).first()
-                if round:
+        if last_finished_match:
+            round = last_finished_match.round
+            if round is None: # when the last finished match is in the group stage
+                round = self.round_set.filter(parent__isnull=True).order_by('-index').first()
+
+            if round:
+                # print(f'last_finished_match = {last_finished_match.name}')
+                round_root_index = round.root_round().index
+                # print(f'round_index = {round_root_index}')
+                if round_root_index == 0:
                     return round
                 else:
-                    return None
-        else:
-            return None
+                    round = self.round_set.filter(parent=None,index=round_root_index-1).first()
+                    if round:
+                        return round
+                    else:
+                        return None
+        return None
 
     def last_started_match(self):
         matches = [m for m in self.all_matches(False) if m.start_date]