tournament in coming

tournament/models.py

@@ -1,8 +1,5 @@
 from __future__ import annotations
 
-from django.db import models
-
-
 from transcendence.abstract.AbstractRoomMember import AbstractRoomMember
 from transcendence.abstract.AbstractRoom import AbstractRoom
 from transcendence.abstract.AbstractRoomManager import AbstractRoomManager
@@ -13,59 +10,52 @@ from games.models import GameModel
 from django.contrib.auth.models import User
 from django.db.models import CASCADE
 from channels.generic.websocket import WebsocketConsumer
+from django.db import models
+
+import json
 
 
 # Create your models here.tu
 class TournamentModel(models.Model):
 
     name = models.CharField(max_length = 100)
-    nb_players = models.IntegerField()
-    rounds = models.IntegerField()
+    nb_participants = models.IntegerField()
+    round = models.IntegerField()
     started = models.BooleanField(default = False)
     finished = models.BooleanField(default = False)
-    winner = models.ForeignKey(ProfileModel, on_delete=CASCADE)
+    winner = models.ForeignKey(ProfileModel, on_delete=CASCADE, blank=True, null=True)
 
-    def _add_player(self, player: ProfileModel) -> None:
-        TournamentPlayerModel(player=player, tournament=self).save()
+    def _register_participant(self, participant: ProfileModel) -> None:
+        TournamentParticipantModel(participant=participant, tournament=self).save()
 
-    def start(self, players: list[ProfileModel]) -> None:
+    def start(self, participants: list[ProfileModel]) -> None:
 
-        self.started = False
+        self.started = True
 
-        for player in players:
-            self._add_player(player)
+        for player in participants:
+            self._register_participant(player)
+
+        for (participant1, participant2) in zip(participants[0::2], participants[1::2]):
+            self.create_game([participant1, participant2], round=1)
 
-        for (player1, player2) in zip(players[0::2], players[1::2]):
-            self.create_game([player1, player2], round=1)
-        
         self.save()
 
-    def create_game(self, players: list[ProfileModel], round: int) -> GameModel:
+    def create_game(self, participants: list[ProfileModel], round: int) -> GameModel:
 
         if (self.started == False):
             return None
-        
-        if (len(players) != 2):
+
+        if (len(participants) != 2):
             return None
-        
+
         from games.models import GameModel
 
-        game: GameModel = GameModel().create(players=players)
+        game: GameModel = GameModel().create(participants)
 
         TournamentGameModel(tournament=self, game=game, round=round).save()
 
         return game
 
-    def start(self, players: list[ProfileModel]) -> int:
-        
-        if (len(players) != self.nb_players):
-            return 1
-        
-        for player in players:
-            TournamentPlayerModel(tournament=self, player=player).save()
-
-        return 0
-
     def get_games(self) -> list[GameModel]:
         return [tournament_game.game for tournament_game in TournamentGameModel.objects.filter(tournament=self)]
     
@@ -78,50 +68,22 @@ class TournamentModel(models.Model):
     def get_winners_by_round(self, round: int) -> list[ProfileModel]:
         return [game.winner for game in self.get_games_by_round(round)]
         
-    def get_players(self) -> list[TournamentPlayerModel]:
-        return TournamentPlayerModel.objects.filter(tournament=self.pk)
+    def get_participants(self) -> list[TournamentParticipantModel]:
+        return TournamentParticipantModel.objects.filter(tournament=self.pk)
 
     def get_state(self) -> str:
         return ("waiting to start", "in progress", "finish")[self.started + self.finished]
     
-    def is_player(self, profile: ProfileModel) -> bool:
-        return TournamentPlayerModel.objects.filter(player=profile, tournament=self).exists()
+    def is_participanting(self, profile: ProfileModel) -> bool:
+        return TournamentParticipantModel.objects.filter(participant=profile, tournament=self).exists()
 
-class TournamentPlayerModel(models.Model):
-    player = models.ForeignKey(ProfileModel, on_delete=CASCADE)
+class TournamentParticipantModel(models.Model):
+    participant = models.ForeignKey(ProfileModel, on_delete=CASCADE)
     tournament = models.ForeignKey(TournamentModel, on_delete=CASCADE)
-
+    #prout à encore frappé
+    
 class TournamentGameModel(models.Model):
 
     tournament = models.ForeignKey(TournamentModel, on_delete=CASCADE, null=True, blank=True)
     round = models.IntegerField()
-    game = models.ForeignKey(GameModel, on_delete=CASCADE)
-
-class TournamentSpectator(AbstractRoomMember):
-    pass
-
-class TournamentPlayer(TournamentSpectator):
-    pass
-
-class TournamentRoom(AbstractRoom):
-    
-    def __init__(self, room_manager: TournamentRoomManager, tournament_id: int):
-        super().__init__(room_manager)
-        self.room_manager: TournamentRoomManager
-        self.id: int = id
-        self.model: TournamentModel = TournamentModel.objects.get(pk=tournament_id)
-    
-
-    def join(self, profile: ProfileModel, socket: WebsocketConsumer) -> TournamentPlayer | TournamentSpectator:
-        if (self.model.started):
-            if (self.model.is_player(profile)):
-                return TournamentPlayer(profile.pk, socket)
-            else:
-                return TournamentSpectator(profile.pk, socket)
-        else:
-            return TournamentSpectator(profile.pk, socket)
-
-class TournamentRoomManager(AbstractRoomManager):
-    pass
-
-tournament_manager: TournamentRoomManager = TournamentRoomManager()
+    game = models.ForeignKey(GameModel, on_delete=CASCADE)