01

pong/game/consumers.py

@@ -1,106 +1,379 @@
-# /pong/game/consumers.py
-
 import json
 from channels.generic.websocket import AsyncWebsocketConsumer
+from asgiref.sync import sync_to_async
 from django.contrib.auth.models import User
 from channels.db import database_sync_to_async
 from .matchmaking import match_maker
 from .tournament import tournament_match_maker
-import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
 
 class GameConsumer(AsyncWebsocketConsumer):
-    async def connect(self):
-        await self.accept()
-        self.game = None
-        print("User connected")
+	async def connect(self):
+		try:
+			await self.accept()
+			self.game = None
+			logger.info("User connected via WebSocket")
+		except Exception as e:
+			logger.error(f"Error during WebSocket connection: {str(e)}")
 
-    async def receive(self, text_data):
-        data = json.loads(text_data)
-        if data['type'] == 'authenticate':
-            await self.authenticate(data['token'])
-        elif data['type'] == 'authenticate2':
-            await self.authenticate2(data['token_1'], data['token_2'])
-        elif data['type'] == 'authenticate3':
-            await self.authenticate3(data['token'])
-        elif data['type'] == 'key_press':
-            if self.game:
-                await self.game.handle_key_press(self, data['key'])
-        elif data['type'] == 'start_tournament':
-            print(f"Start TOURNAMENT received by {self.user}")
-            # Run the tournament in the background
-            asyncio.create_task(tournament_match_maker.start_tournament())
+	async def receive(self, text_data):
+		try:
+			logger.debug(f"Received data: {text_data}")
+			data = json.loads(text_data)
+			message_type = data.get('type')
 
-    async def authenticate(self, token):
-        user = await self.get_user_from_token(token)
-        if user:
-            self.user = user
-            await self.send(text_data=json.dumps({'type': 'authenticated'}))
-            print(f"User {self.user} authenticated")
-            await self.join_waiting_room()
-        else:
-            await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
-            print("Authentication failed")
+			if message_type == 'authenticate':
+				await self.authenticate(data.get('token'))
+			elif message_type == 'authenticate2':
+				await self.authenticate2(data.get('token_1'), data.get('token_2'))
+			elif message_type == 'authenticate3':
+				await self.authenticate3(data.get('token'))
+			elif message_type == 'key_press':
+				if self.game:
+					await self.game.handle_key_press(self, data.get('key'))
+				else:
+					await match_maker.handle_key_press(self, data.get('key'))
+			else:
+				logger.warning(f"Received unknown message type: {message_type}")
+				await self.send(text_data=json.dumps({'type': 'error', 'message': 'Unknown message type'}))
+		except json.JSONDecodeError as e:
+			logger.error(f"JSON decode error: {str(e)} - Data received: {text_data}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Invalid JSON format'}))
+		except Exception as e:
+			logger.error(f"Error in WebSocket receive: {str(e)}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
 
-    @database_sync_to_async
-    def get_user_from_token(self, token):
-        try:
-            user = User.objects.filter(auth_token=token).first()
-            return user
-        except User.DoesNotExist:
-            return None
+	async def authenticate(self, token):
+		if not token:
+			logger.error("Token is None, authentication cannot proceed")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Token is missing'}))
+			return
+		try:
+			user = await self.get_user_from_token(token)
+			if user:
+				self.user = user
+				await self.send(text_data=json.dumps({'type': 'authenticated'}))
+				logger.info(f"User {self.user} authenticated")
+				await self.join_waiting_room()
+			else:
+				logger.warning(f"Authentication failed for token: {token}")
+				await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
+		except Exception as e:
+			logger.error(f"Error during authentication: {str(e)}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
 
-    async def join_waiting_room(self):
-        await self.send(text_data=json.dumps({'type': 'waiting_room'}))
-        await match_maker.add_player(self)
+	async def authenticate2(self, token_1, token_2):
+		try:
+			user = await self.get_user_from_token(token_1)
+			if user:
+				self.user = user
+				await self.send(text_data=json.dumps({'type': 'authenticated'}))
+				logger.info(f"User {self.user} authenticated with token_1")
 
-    async def authenticate2(self, token, token2):
-        user = await self.get_user_from_token(token)
-        if user:
-            self.user = user
-            await self.send(text_data=json.dumps({'type': 'authenticated'}))
-            print(f"User {self.user} authenticated")
-            user2 = await self.get_user_from_token2(token2)
-            if user2:
-                self.user2 = user2
-                await self.send(text_data=json.dumps({'type': 'authenticated'}))
-                print(f"User {self.user2} authenticated")
-                await match_maker.create_game(self, None, True)
-            else:
-                await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
-                print("Authentication failed")
-        else:
-            await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
-            print("Authentication failed")
+				user2 = await self.get_user_from_token2(token_2)
+				if user2:
+					self.user2 = user2
+					await self.send(text_data=json.dumps({'type': 'authenticated'}))
+					logger.info(f"User {self.user2} authenticated with token_2")
+					await match_maker.create_game(self, None, True)
+				else:
+					logger.warning(f"Authentication failed for token_2: {token_2}")
+					await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed for user 2'}))
+			else:
+				logger.warning(f"Authentication failed for token_1: {token_1}")
+				await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed for user 1'}))
+		except Exception as e:
+			logger.error(f"Error during dual authentication: {str(e)}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
 
-    @database_sync_to_async
-    def get_user_from_token2(self, token):
-        try:
-            user2 = User.objects.filter(auth_token=token).first()
-            return user2
-        except User.DoesNotExist:
-            return None
+	async def authenticate3(self, token):
+		try:
+			user = await self.get_user_from_token(token)
+			if user:
+				self.user = user
+				await self.send(text_data=json.dumps({'type': 'authenticated'}))
+				logger.info(f"User {self.user} authenticated for tournament")
+				await self.join_tournament_waiting_room()
+			else:
+				logger.warning(f"Authentication failed for token: {token}")
+				await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
+		except Exception as e:
+			logger.error(f"Error during tournament authentication: {str(e)}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
 
-    async def authenticate3(self, token):
-        user = await self.get_user_from_token(token)
-        if user:
-            self.user = user
-            await self.send(text_data=json.dumps({'type': 'authenticated'}))
-            print(f"User {self.user.username} authenticated for tournament")
-            await self.join_tournament_waiting_room()
-        else:
-            await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
-            print("Tournament authentication failed")
+	@database_sync_to_async
+	def get_user_from_token(self, token):
+		try:
+			user = User.objects.filter(auth_token=token).first()
+			logger.debug(f"User found: {user} for token: {token}")
+			return user
+		except User.DoesNotExist:
+			logger.warning(f"User not found for token: {token}")
+			return None
 
-    async def join_tournament_waiting_room(self):
-        await tournament_match_maker.add_player(self)
+	@database_sync_to_async
+	def get_user_from_token2(self, token):
+		try:
+			user2 = User.objects.filter(auth_token=token).first()
+			logger.debug(f"User2 found: {user2} for token: {token}")
+			return user2
+		except User.DoesNotExist:
+			logger.warning(f"User not found for token_2: {token}")
+			return None
 
-    async def disconnect(self, close_code):
-        if self.game:
-            await self.game.end_game(disconnected_player=self)
-        await match_maker.remove_player(self)
-        await tournament_match_maker.remove_player(self)
-        print(f"User {self.user.username if hasattr(self, 'user') else 'Unknown'} disconnected")
+	async def join_waiting_room(self):
+		logger.info("Joining waiting room")
+		await self.send(text_data=json.dumps({'type': 'waiting_room'}))
+		await match_maker.add_player(self)
 
-    async def set_game(self, game):
-        print(f"({self.user}) Game set to: {game}")
-        self.game = game
+	async def join_tournament_waiting_room(self):
+		logger.info("Joining tournament waiting room")
+		await tournament_match_maker.add_player(self)
+
+	async def disconnect(self, close_code):
+		try:
+			if self.game:
+				await self.game.end_game(disconnected_player=self)
+			await match_maker.remove_player(self)
+			await tournament_match_maker.remove_player(self)
+			logger.info(f"User {self.user.username if hasattr(self, 'user') else 'Unknown'} disconnected")
+		except Exception as e:
+			logger.error(f"Error during WebSocket disconnection: {str(e)}")
+
+	async def set_game(self, game):
+		logger.info(f"Setting game: {game}")
+		self.game = game
+###############################CHAT############################################
+class ChatConsumer(AsyncWebsocketConsumer):
+	groups = {}
+
+	async def connect(self):
+		try:
+			# Récupérer le nom de la room
+			self.room_group_name = self.scope['url_route']['kwargs']['room_name']
+		
+			# Accepter la connexion WebSocket
+			await self.accept()
+
+			logger.info(f"Connexion au WebSocket de chat dans la room {self.room_group_name}")
+
+			# Ajouter l'utilisateur au groupe en mémoire
+			if self.room_group_name not in self.groups:
+				self.groups[self.room_group_name] = []
+			self.groups[self.room_group_name].append(self.channel_name)
+
+			logger.info(f"User {self.channel_name} added to group {self.room_group_name}")
+
+		except Exception as e:
+			logger.error(f"Erreur lors de la connexion WebSocket: {str(e)}")
+
+
+	async def disconnect(self, close_code):
+		try:
+			# Retirer l'utilisateur du groupe en mémoire
+			if self.room_group_name in self.groups:
+				self.groups[self.room_group_name].remove(self.channel_name)
+				if not self.groups[self.room_group_name]:
+					del self.groups[self.room_group_name]
+
+			await self.send_group_message(
+				self.room_group_name,
+				{
+					'type': 'chat_message',
+					'message': f'{self.user.username if hasattr(self, "user") else "Unknown"} a quitté le chat',
+					'username': self.user.username if hasattr(self, "user") else "Unknown",
+					'room': self.room_group_name
+				}
+			)
+			logger.info(f"{self.user.username if hasattr(self, 'user') else 'Unknown'} déconnecté du WebSocket de chat dans la room {self.room_group_name}")
+		except Exception as e:
+			logger.error(f"Erreur lors de la déconnexion WebSocket du chat: {str(e)}")
+
+	async def receive(self, text_data):
+		try:
+			data = json.loads(text_data)
+			message_type = data.get('type')
+			username = data.get('username').strip().lower()  # Normalisation du nom d'utilisateur
+
+			# Log pour vérifier que le username est bien reçu
+			logger.info(f"Message reçu avec username: {username}")
+			if not username:
+				logger.error(f"Username missing in message: {data}")
+				await self.send(text_data=json.dumps({'type': 'error', 'message': 'Username is missing'}))
+				return
+
+			# Gestion des types de messages
+			if message_type == 'authenticate':
+				await self.authenticate(data.get('token'), username)
+
+			elif message_type == 'chat_message':
+				if 'message' not in data:
+					logger.error(f"Format de message incorrect : {data}")
+					await self.send(text_data=json.dumps({'type': 'error', 'message': 'Format de message incorrect'}))
+					return
+
+				message = data['message']
+
+				# Envoyer le message à tous les autres utilisateurs de la room
+				await self.send_group_message(
+					self.room_group_name,
+					{
+						'type': 'chat_message',
+						'message': message,
+						'username': username,
+						'room': self.room_group_name
+					}
+				)
+
+			# Gestion de la commande /b pour bloquer un utilisateur
+			elif message_type == 'block_user':
+				target_user = data.get('target_user').strip().lower()
+				if target_user == username:
+					await self.send(text_data=json.dumps({'type': 'error', 'message': 'You cannot block yourself'}))
+				else:
+					await self.handle_block_user(data)
+
+			# Gestion de la commande /i pour inviter un utilisateur
+			elif message_type == 'invite_user':
+				target_user = data.get('target_user').strip().lower()
+				if target_user == username:
+					await self.send(text_data=json.dumps({'type': 'error', 'message': 'You cannot invite yourself'}))
+				else:
+					await self.handle_invite_user(data)
+
+			else:
+				logger.warning(f"Unhandled message type: {message_type}")
+				await self.send(text_data=json.dumps({'type': 'error', 'message': 'Unhandled message type'}))
+
+		except json.JSONDecodeError as e:
+			logger.error(f"Erreur de décodage JSON : {str(e)} - Données reçues : {text_data}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Format JSON invalide'}))
+		except Exception as e:
+			logger.error(f"Erreur lors de la réception du message du chat: {str(e)}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Erreur interne du serveur'}))
+
+	async def handle_block_user(self, data):
+		username = data['username'].strip().lower()  # Normalisation du nom d'utilisateur
+		target_user = data['target_user'].strip().lower()
+
+		# Utiliser self.room_group_name pour vérifier que l'utilisateur ciblé est bien dans la bonne room
+		if target_user not in self.groups.get(self.room_group_name, []):
+			logger.error(f"Target user {target_user} does not exist in room {self.room_group_name}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': f'Target user {target_user} not found in room {self.room_group_name}'}))
+			return
+
+		logger.info(f"Block request: {username} wants to block {target_user} in room {self.room_group_name}")
+
+		if target_user == username:
+			logger.warning(f"Block attempt failed: {username} tried to block themselves")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'You cannot block yourself'}))
+		else:
+			logger.info(f"{username} successfully blocked {target_user}")
+			await self.send(text_data=json.dumps({'type': 'success', 'message': f'You have blocked {target_user} in room {self.room_group_name}'}))
+
+	async def handle_invite_user(self, data):
+		username = data['username'].strip().lower() 
+		target_user = data['target_user'].strip().lower()
+
+		# Utiliser self.room_group_name pour inviter l'utilisateur dans la room active
+		room = self.room_group_name
+
+		# Vérification que le joueur à inviter est dans la room
+		if target_user not in self.groups.get(room, []):
+			logger.error(f"Target user {target_user} does not exist in room {room}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': f'Target user {target_user} not found in room {room}'}))
+			return
+
+		logger.info(f"Invitation request: {username} wants to invite {target_user} to a quick match in room {room}")
+
+		if target_user == username:
+			logger.warning(f"Invite attempt failed: {username} tried to invite themselves")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'You cannot invite yourself'}))
+		else:
+			logger.info(f"{username} successfully sent an invitation to {target_user} in room {room}")
+			await self.send_group_message(room, {
+				'type': 'invite',
+				'message': f'{username} invited {target_user} to a quick match',
+				'username': username,
+				'target_user': target_user
+			})
+			await self.send(text_data=json.dumps({'type': 'success', 'message': f'Invitation sent to {target_user} in room {room}'}))
+
+
+	async def authenticate(self, token, username):
+		if not token:
+			logger.error("Token is None, authentication cannot proceed")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Token is missing'}))
+			return
+		try:
+			user = await self.get_user_from_token(token)
+			if user:
+				self.user = user
+				logger.info(f"User {username} authenticated successfully with token: {token}")
+			
+				# Envoyer un message d'authentification réussie au client
+				await self.send(text_data=json.dumps({'type': 'authenticated', 'username': username}))
+
+				# Envoyer le message de bienvenue après l'authentification réussie
+				await self.send_group_message(
+					self.room_group_name,
+					{
+						'username': username,
+						'room': self.room_group_name,
+						'type': 'chat_message',
+						'message': f' a rejoint le chat {self.room_group_name}',
+					}
+				)
+			else:
+				logger.warning(f"Authentication failed for token: {token}")
+				await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
+		except Exception as e:
+			logger.error(f"Error during authentication: {str(e)}")
+			await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
+
+	@sync_to_async
+	def get_user_from_token(self, token):
+		try:
+			user = User.objects.filter(auth_token=token).first()
+			logger.debug(f"User found: {user} for token: {token}")
+			return user
+		except User.DoesNotExist:
+			logger.warning(f"User not found for token: {token}")
+			return None
+
+	async def send_group_message(self, group_name, message):
+		# Utilisation de self.room_group_name pour s'assurer que la bonne room est utilisée
+		group_name = self.room_group_name  # Utilisation explicite de self.room_group_name
+
+		if group_name in self.groups:
+			logger.debug(f"Sending message to group {group_name}: {message}")
+			for channel_name in self.groups[group_name]:
+				try:
+					await self.channel_layer.send(channel_name, {
+						'type': 'chat_message',
+						'message': message['message'],
+						'username': message['username'],
+						'room': message['room']
+					})
+					logger.debug(f"Message sent to {channel_name} in room {message['room']}: {message}")
+				except Exception as e:
+					logger.error(f"Failed to send message to {channel_name} in room {group_name}: {str(e)}")
+		else:
+			logger.error(f"Group {group_name} does not exist, unable to send message")
+
+	async def chat_message(self, event):
+		message = event['message']
+		username = event.get('username', 'Anonyme')
+		room = event.get('room', 'unknown')
+
+		# Log pour vérifier le username avant envoi
+		logger.info(f"Sending chat message from username: {username} in room: {room}")
+
+		# Envoyer le message au WebSocket
+		await self.send(text_data=json.dumps({
+			'type': 'chat_message',
+			'message': f'{username}: {message}',
+			'room': room
+		}))

pong/game/game.py

@@ -4,14 +4,11 @@ import json
 import asyncio
 import random
 from datetime import datetime
-from .utils import handle_game_data, getlen
+from .utils import handle_game_data
 from asgiref.sync import sync_to_async
-from .models import Tournoi
+
 
 class Game:
-    # Global variable to handle the using of the database
-    USING_DB = False
-
     def __init__(self, game_id, player1, player2, localgame):
         self.game_id = game_id
         self.player1 = player1
@@ -31,10 +28,9 @@ class Game:
                 'game_text': ''
             }
         else:
-            # Set botgame to True if either player1 or player2 is None
-            self.botgame = player1 is None or player2 is None
+            self.botgame = player2 is None
             self.game_state = {
-                'player1_name': player1.user.username if player1 else 'BOT',
+                'player1_name': player1.user.username,
                 'player2_name': player2.user.username if player2 else 'BOT',
                 'player1_position': 150,
                 'player2_position': 150,
@@ -51,64 +47,57 @@ class Game:
         self.p2_mov = 0
         self.bt1 = 0
         self.bt2 = 0
-        self.start_time = datetime.now()
-        self.future_ball_position = {'x': 390, 'y': 190}
+        self.start_time = None
 
     async def start_game(self):
-        print(f"- Game #{self.game_id} STARTED ({self.game_state['player1_name']} vs {self.game_state['player2_name']}) --- ({self})")
+        print(f"- Game #{self.game_id} STARTED")
         self.game_loop_task = asyncio.create_task(self.game_loop())
+        self.start_time = datetime.now()
         print(f"  Begin MATCH at: {self.start_time}")
 
     async def game_loop(self):
         print("  In the game loop..")
-        x = 59
+        x = 0
         while not self.ended:
             if self.botgame:
                 x += 1
                 if x == 60:
-                    # Random BOT difficulty..
-                    steps = 60#random.randint(10, 60)
-                    self.future_ball_position = await self.predict_ball_trajectory(steps)
+                    await self.update_bot_position()
                     x = 0
-            if self.botgame:
-                await self.update_bot_position()
             await self.handle_pad_movement()
             await self.update_game_state()
             await self.send_game_state()
             await asyncio.sleep(1/60)  # Around 60 FPS
 
     async def update_bot_position(self):
-        #future_ball_position = self.predict_ball_trajectory()
-        target_y = self.future_ball_position['y']
+        future_ball_position = self.predict_ball_trajectory()
+
+        target_y = future_ball_position['y']
         player2_position = self.game_state['player2_position']
         
         # Adjusts bot position based on expected ball position
         if player2_position < target_y < player2_position + 80:
             pass  #bot already placed
         elif player2_position < target_y:
-            self.p2_mov = 1
-            #self.game_state['player2_position'] = min(player2_position + (50 * self.speed), 300)
+            self.game_state['player2_position'] = min(player2_position + (50 * self.speed), 300)
         elif player2_position + 80 > target_y:
-            self.p2_mov = -1
-            #self.game_state['player2_position'] = max(player2_position - (50 * self.speed), 0)
+            self.game_state['player2_position'] = max(player2_position - (50 * self.speed), 0)
 
-    async def predict_ball_trajectory(self, steps=60):    
+    def predict_ball_trajectory(self, steps=60):
+    
         future_x = self.game_state['ball_position']['x']
         future_y = self.game_state['ball_position']['y']
         velocity_x = self.game_state['ball_velocity']['x']
         velocity_y = self.game_state['ball_velocity']['y']
+
         for _ in range(steps):
             future_x += velocity_x
-            if future_x <= 10:
-                future_x = 10
-                velocity_x = -velocity_x
-            elif future_x >= 790:
-                future_x = 790
-            else:
-                future_y += velocity_y
-                # Dealing with bounces off walls
-                if future_y <= 10 or future_y >= 390:
-                    velocity_y = -velocity_y  # Reverse the direction of vertical movement
+            future_y += velocity_y
+
+            # Dealing with bounces off walls
+            if future_y <= 0 or future_y >= 300:
+                velocity_y = -velocity_y  # Reverse the direction of vertical movement
+
         return {'x': future_x, 'y': future_y}
 
     async def update_game_state(self):
@@ -221,10 +210,10 @@ class Game:
             self.ended = True
             if self.game_loop_task:
                 self.game_loop_task.cancel()            
-            print(f"- Game #{self.game_id} ENDED --- ({self})")
+            print(f"- Game #{self.game_id} ENDED")
 
             end_time = datetime.now()
-            duration = (end_time - self.start_time).total_seconds() / 60
+            duration = (end_time -  self.start_time).total_seconds() / 60
 
             # Notify that one player left the game      
             if disconnected_player:
@@ -246,17 +235,6 @@ class Game:
             if not self.botgame:
                 if not self.localgame:
                     await self.player2.send(end_message)
-            while (Game.USING_DB):
-                await asyncio.sleep(1)
-            Game.USING_DB = True
-            if hasattr(self, 'tournament'):
-               print(f"*** Game #{self.game_id} from tournament: {self.tournament.tournoi_reg.name} ENDED ***")
-               await sync_to_async(handle_game_data)(self.game_state['player1_name'], self.game_state['player2_name'],
-                           self.game_state['player1_score'], self.game_state['player2_score'],
-                           self.bt1, self.bt2, duration, True, self.tournament.tournoi_reg)
-               print(f"*** Game #{self.game_id} from tournament: {self.tournament.tournoi_reg.name} is REGISTERED ***")
-            else:
-                await sync_to_async(handle_game_data)(self.game_state['player1_name'], self.game_state['player2_name'],
+            await sync_to_async(handle_game_data)(self.game_state['player1_name'], self.game_state['player2_name'],
                            self.game_state['player1_score'], self.game_state['player2_score'],
                            self.bt1, self.bt2, duration, False, None)
-            Game.USING_DB = False

pong/game/matchmaking.py

@@ -26,8 +26,7 @@ class MatchMaker:
         for game in self.active_games.values():
             if player in [game.player1, game.player2]:
                 await game.end_game(disconnected_player=player)
-                if game.game_id in self.active_games:
-                    del self.active_games[game.game_id]
+                del self.active_games[game.game_id]
                 break
 
     async def match_loop(self):
@@ -103,5 +102,11 @@ class MatchMaker:
                     'player2': 'BOT'
                 }))
 
+    async def handle_key_press(self, player, key):
+        for game in self.active_games.values():
+            if player in [game.player1, game.player2]:
+                await game.handle_key_press(player, key)
+                break
+
 # Instance of the class
 match_maker = MatchMaker()

pong/game/migrations/0002_alter_match_winner.py

@@ -1,19 +0,0 @@
-# Generated by Django 5.0.7 on 2024-07-31 16:04
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('game', '0001_initial'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='match',
-            name='winner',
-            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='won_matches', to='game.player'),
-        ),
-    ]

pong/game/migrations/0003_alter_tournoi_date.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.1.1 on 2024-09-10 14:17
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('game', '0002_alter_match_winner'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='tournoi',
-            name='date',
-            field=models.DateField(auto_now_add=True),
-        ),
-    ]

pong/game/models.py

@@ -1,9 +1,13 @@
-# /pong/game/models.py
-
 from django.db import models
 from django.contrib.auth.models import User
+from django.core.exceptions import ValidationError
+import logging
 
+logger = logging.getLogger(__name__)
+
+# Ajout d'un champ auth_token à la classe User
 User.add_to_class('auth_token', models.CharField(max_length=100, null=True, blank=True, unique=True))
+logger.debug("Ajout du champ auth_token à la classe User")
 
 class Player(models.Model):
     name = models.CharField(max_length=100)
@@ -20,23 +24,33 @@ class Player(models.Model):
     num_won_tournaments = models.PositiveSmallIntegerField(default=0)
 
     def __str__(self):
-        return self.name 
+        return self.name
+
+    def save(self, *args, **kwargs):
+        logger.info(f"Saving player: {self.name}")
+        super().save(*args, **kwargs)
+        logger.info(f"Player {self.name} saved successfully")
 
 class Tournoi(models.Model):
     name = models.CharField(max_length=200)
     nbr_player = models.PositiveSmallIntegerField()
-    date = models.DateField(auto_now_add=True)
+    date = models.DateField()
     winner = models.ForeignKey('Player', on_delete=models.SET_NULL, null=True)
 
     def __str__(self):
         return self.name
 
+    def save(self, *args, **kwargs):
+        logger.info(f"Saving tournament: {self.name}")
+        super().save(*args, **kwargs)
+        logger.info(f"Tournament {self.name} saved successfully")
+
 class Match(models.Model):
     player1 = models.ForeignKey('Player', related_name='match_as_player1', on_delete=models.CASCADE)
     player2 = models.ForeignKey('Player', related_name='match_as_player2', on_delete=models.CASCADE)
     score_player1 = models.PositiveSmallIntegerField()
     score_player2 = models.PositiveSmallIntegerField()
-    winner = models.ForeignKey('Player', related_name='won_matches',on_delete=models.CASCADE, null=True)
+    winner = models.ForeignKey('Player', related_name='won_matches', on_delete=models.CASCADE, null=True)
     nbr_ball_touch_p1 = models.PositiveIntegerField()
     nbr_ball_touch_p2 = models.PositiveIntegerField()
     duration = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
@@ -45,6 +59,7 @@ class Match(models.Model):
     tournoi = models.ForeignKey('Tournoi', related_name='matches', on_delete=models.SET_NULL, null=True)
 
     def clean(self):
+        logger.debug(f"Cleaning match: {self.player1.name} vs {self.player2.name}")
         if self.score_player1 < 0 or self.score_player2 < 0:
             raise ValidationError('Les scores doivent être positifs.')
         if self.score_player1 > self.score_player2 and self.winner != self.player1:
@@ -54,8 +69,10 @@ class Match(models.Model):
         super().clean()
 
     def save(self, *args, **kwargs):
+        logger.info(f"Saving match: {self.player1.name} vs {self.player2.name}")
         self.clean()
         super().save(*args, **kwargs)
+        logger.info(f"Match {self.player1.name} vs {self.player2.name} saved successfully")
 
     def __str__(self):
-        return f"{self.player1.name} vs {self.player2.name}"
+        return f"{self.player1.name} vs {self.player2.name}"

pong/game/routing.py

@@ -1,8 +1,15 @@
 # /pong/game/routing.py
-
 from django.urls import re_path
 from . import consumers
+import logging
+
+logger = logging.getLogger(__name__)
+
+logger.debug("Configuring WebSocket routing patterns")
 
 websocket_urlpatterns = [
-    re_path(r'ws/game/$', consumers.GameConsumer.as_asgi()),
+    re_path(r'ws/game/$', consumers.GameConsumer.as_asgi(), name='game_ws'),
+    re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()),
 ]
+
+logger.info("WebSocket routing patterns configured successfully")

pong/game/templates/pong/tournament_brackets.html

@@ -1,60 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Tournament Brackets</title>
-    <style>
-        .tournament-bracket {
-            display: flex;
-            padding: 20px;
-            font-family: Arial, sans-serif;
-            overflow-x: auto;
-        }
-        .round {
-            display: flex;
-            flex-direction: column;
-            justify-content: space-around;
-            margin-right: 40px;
-        }
-        .match {
-            display: flex;
-            flex-direction: column;
-        }
-        .player {
-            width: 150px;
-            height: 30px;
-            line-height: 30px;
-            background-color: #000000;
-            border: 1px solid #ffffff;
-            margin: 2px 0;
-            padding: 0 10px;
-            white-space: nowrap;
-            overflow: hidden;
-            text-overflow: ellipsis;
-        }
-        .player.winner {
-            background-color: #00ff3c;
-            font-weight: bold;
-        }
-    </style>
-</head>
-<body>
-    <div class="tournament-bracket">
-        {% for round in tournament_rounds %}
-        <div class="round">
-            {% for match in round %}
-            <div class="match">
-                <div class="player {% if match.winner == match.player1 %}winner{% endif %}">
-                    {{ match.player1 }}
-                </div>
-                <div class="player {% if match.winner == match.player2 %}winner{% endif %}">
-                    {{ match.player2|default:"BYE" }}
-                </div>
-            </div>
-            {% endfor %}
-        </div>
-        {% endfor %}
-    </div>
-</body>
-</html>

pong/game/templates/pong/tournament_waiting_room.html

@@ -1,20 +1,10 @@
-<!-- pong/tournament_waiting_room.html -->
+<!-- templates/tournament_waiting_room.html -->
 <div class="tournament-waiting-room">
     <h2>Tournament Waiting Room</h2>
-    
-    <p>Players currently waiting: {{ players_count }}</p>
-    <p>Minimum players needed to start: {{ min_players_to_start }}</p>
-    
-    <h3>Players:</h3>
+    <p>Players currently waiting: {{ players|length }}</p>
     <ul>
-    {% for player in players %}
-        <li>{{ player }}</li>
-    {% endfor %}
+        {% for player in players %}
+            <li>{{ player }}</li>
+        {% endfor %}
     </ul>
-
-    {% if players_count >= min_players_to_start %}
-        <button id="start-tournament-btn">Start Tournament</button>
-    {% else %}
-        <p>Waiting for more players to join...</p>
-    {% endif %}
 </div>

pong/game/tournament.py

@@ -1,224 +1,49 @@
 # /pong/game/tournament.py
-
 import json
-import asyncio
 from django.template.loader import render_to_string
-import random
-from .matchmaking import match_maker
-from .game import Game
-from .models import Tournoi
-from .utils import create_tournament, update_tournament, getlen
-from asgiref.sync import sync_to_async
+import logging
 
-TOURNAMENT_NAMES =  [
-    "Champion's Clash", "Ultimate Showdown", "Battle Royale",
-    "Victory's Cup", "Legends Tournament", "Elite Series", "Clash of 42",
-    "Shibuya Incident", "Cunning Game", "Elite of the Stars", "Chaku's Disciples"
-]
-
-class TournamentMatch(Game):
-    def __init__(self, game_id, player1, player2, tournament):
-        # Initialize the parent Game class with the provided parameters
-        super().__init__(game_id, player1, player2, False)        
-        # Store the current game instance in active games
-        match_maker.active_games[game_id] = self        
-        # Store the tournament instance
-        self.tournament = tournament
-
-    async def end_game(self, disconnected_player=None):
-        # Call the parent class's end_game method
-        await super().end_game(disconnected_player)
-        # Handle the end of the match in the tournament context
-        await self.tournament.handle_match_end(self)
-        if self.game_id in match_maker.active_games:
-            del match_maker.active_games[self.game_id]
+logger = logging.getLogger(__name__)
 
 class TournamentMatchMaker:
     def __init__(self):
         self.waiting_players = []
-        self.matches = []
-        self.rounds = []
-        self.current_round = 0
-        self.games = 0
-        self.tournament_state = "waiting" #Can be "waiting", "in_progress", or "ended"
-        self.name = random.choice(TOURNAMENT_NAMES)
-        self.final_name = ""
-        self.tournoi_reg = None
+        logger.debug("TournamentMatchMaker initialized with an empty waiting_players list")
 
     async def add_player(self, player):
-        if self.tournament_state == "waiting" and player not in self.waiting_players:
+        if player not in self.waiting_players:
             self.waiting_players.append(player)
-            if player:
-                print(f"User {player.user.username} joins the TOURNAMENT WAITING ROOM")
-            else:
-                print("BOT joins the TOURNAMENT WAITING ROOM")
+            logger.info(f"User {player.user.username} added to the TOURNAMENT WAITING ROOM")
             await self.update_waiting_room()
-
-    async def update_waiting_room(self):
-        html = self.generate_waiting_room_html()
-        for player in self.waiting_players:
-            await self.send_to_player(player, {
-                'type': 'update_tournament_waiting_room',
-                'html': html
-            })
-
-    def generate_waiting_room_html(self):
-        context = {
-            'players': [player.user.username if player else 'BYE' for player in self.waiting_players],
-            'tournament_state': self.tournament_state,
-            'players_count': len(self.waiting_players),
-            'min_players_to_start': 3  # You can adjust this number as needed
-        }
-        return render_to_string('pong/tournament_waiting_room.html', context)
-
-    async def send_to_player(self, player, data):
-        if player:
-            await player.send(json.dumps(data))
+        else:
+            logger.warning(f"User {player.user.username} is already in the TOURNAMENT WAITING ROOM")
 
     async def remove_player(self, player):
         if player in self.waiting_players:
             self.waiting_players.remove(player)
+            logger.info(f"User {player.user.username} removed from the TOURNAMENT WAITING ROOM")
             await self.update_waiting_room()
+        else:
+            logger.warning(f"Attempt to remove non-existent user {player.user.username} from the TOURNAMENT WAITING ROOM")
 
-    # Tournament start method
-    async def start_tournament(self):
-        if len(self.waiting_players) < 3:
-            return False
-        random.shuffle(self.waiting_players)
-        '''if (len(self.waiting_players) % 2) != 0:
-            print("Adding a BYE to the tournament..")
-            await self.add_player(None)'''
-        self.tournament_state = "in_progress"
-        self.current_round = 0
-        len_tournament = await sync_to_async(getlen)()
-        self.final_name = self.name + " #" + str(len_tournament + 1)
-        self.tournoi_reg = await sync_to_async(create_tournament)(self.final_name, len(self.waiting_players))
-        await self.advance_tournament()
-        return True
-
-    async def advance_tournament(self):
-        players = self.waiting_players
-        while len(players) > 1:
-            self.current_round += 1
-            print(f"Starting round {self.current_round} with {len(players)} players")            
-            await self.create_matches(players)
-            await self.update_brackets()
-            await self.start_round_matches()            
-            # Wait for all matches in the current round to finish
-            current_round_matches = self.rounds[-1]
-            while not all(match.ended for match in current_round_matches):
-                await asyncio.sleep(1)  # Wait for 1 second before checking again            
-            # Get winners for the next round
-            players = self.get_round_winners()
-            print(f"Round {self.current_round} finished. {len(players)} players advancing.")        
-        # Tournament has ended
-        await self.update_brackets()
-        await self.end_tournament(players[0] if players else None)
-
-    async def create_matches(self, players):
-        matches = []
-        for i in range(0, len(players), 2):
-            self.games += 1
-            if i + 1 < len(players):
-                # Create a new instance of TournamentMatch for this round
-                match = TournamentMatch(self.games, players[i], players[i + 1], self)
-                matches.append(match)
-            else:
-                # Create a BYE match where the second player is None
-                match = TournamentMatch(self.games, players[i], None, self) # BYE match
-                matches.append(match)
-            
-            # Assign the new match instance to the players
-            if players[i]:
-                await players[i].set_game(match)
-            if i + 1 < len(players):
-                if players[i + 1]:
-                    await players[i + 1].set_game(match)
-
-        self.rounds.append(matches)
-        self.matches.extend(matches)
-
-    async def update_brackets(self):
-        html = self.generate_bracket_html()
+    async def update_waiting_room(self):
+        logger.debug("Updating TOURNAMENT WAITING ROOM")
+        html = self.generate_waiting_room_html()
         for player in self.waiting_players:
-            await self.send_to_player(player, {
-                'type': 'update_brackets',
+            await player.send(json.dumps({
+                'type': 'update_waiting_room',
                 'html': html
-            })
+            }))
+        logger.info("TOURNAMENT WAITING ROOM updated and sent to all players")
 
-    def generate_bracket_html(self):
+    def generate_waiting_room_html(self):
+        logger.debug("Generating TOURNAMENT WAITING ROOM HTML")
         context = {
-            'tournament_rounds': self.get_tournament_data()
+            'players': [player.user.username for player in self.waiting_players]
         }
-        return render_to_string('pong/tournament_brackets.html', context)
-
-    def get_tournament_data(self):
-        return [
-            [
-                {
-                    'player1': match.player1.user.username if match.player1 else 'BYE',
-                    'player2': match.player2.user.username if match.player2 else 'BYE',
-                    'winner': match.game_state['player1_name'] if match.game_state['player1_score'] > match.game_state['player2_score'] else match.game_state['player2_name'] if match.ended else None,
-                    'score1': match.game_state['player1_score'],
-                    'score2': match.game_state['player2_score']
-                }
-                for match in round_matches
-            ]
-            for round_matches in self.rounds
-        ]
-
-    async def start_round_matches(self):
-        print(f"Starting TOURNAMENT round #{self.current_round}")
-        for match in self.rounds[-1]:
-            if match.player1 and match.player2:
-                await match_maker.notify_players(match.player1, match.player2, match.game_id, False)
-                asyncio.create_task(match.start_game())
-            elif match.player1:
-                # Handle BYE match
-                await match_maker.notify_players(match.player1, match.player2, match.game_id, False)
-                #asyncio.create_task(match.start_game())
-                match.game_state['player1_score'] = 3
-                match.game_state['player2_score'] = 0
-                await match.end_game()
-                await self.send_game_text(match.player1, "You lucky bastard! You got an auto-win!")
-
-    async def send_game_text(self, player, text):
-        message = json.dumps({
-            'type': 'game_text_update',
-            'game_text': text
-        })
-        await player.send(message)
-
-    def get_round_winners(self):
-        winners = []
-        for match in self.rounds[-1]:
-            if match.ended:
-                winner = match.player1 if match.game_state['player1_score'] > match.game_state['player2_score'] else match.player2
-                #if winner:
-                winners.append(winner)
-        return winners
-
-    async def end_tournament(self, winner):
-        self.tournament_state = "ended"
-        winner_username = winner.user.username if winner else "No winner"
-        print(f"The TOURNAMENT winner is {winner_username}")
-        for player in self.waiting_players:
-            await self.send_to_player(player, {
-                'type': 'tournament_end',
-                'winner': winner_username
-            })
-        
-        await sync_to_async(update_tournament)(self.final_name, winner_username)
-        # Reset tournament state
-        self.waiting_players = []
-        self.matches = []
-        self.rounds = []
-        self.current_round = 0
-        self.games = 0
-        self.tournament_state = "waiting"
-
-    async def handle_match_end(self, match):
-        await self.update_brackets()
+        html = render_to_string('pong/tournament_waiting_room.html', context)
+        logger.info("TOURNAMENT WAITING ROOM HTML generated successfully")
+        return html
 
 # Instance of the class
-tournament_match_maker = TournamentMatchMaker()
+tournament_match_maker = TournamentMatchMaker()

pong/game/urls.py

@@ -2,10 +2,9 @@
 
 from django.urls import path, include
 from . import views
-from rest_framework.routers import DefaultRouter
+#from rest_framework.routers import DefaultRouter
 from .views import match_list_json, player_list_json, tournoi_list_json
 
-
 urlpatterns = [
     path('', views.index, name='index'),
     path('check_user_exists/', views.check_user_exists, name='check_user_exists'),

pong/game/utils.py

@@ -1,3 +1,4 @@
+import logging
 from .models import Player, Tournoi, Match
 from django.core.exceptions import ValidationError
 from django.shortcuts import get_object_or_404
@@ -5,55 +6,62 @@ from django.db.models import Max, Sum, F
 from datetime import timedelta
 from channels.db import database_sync_to_async
 
+logger = logging.getLogger(__name__)
+
 def handle_game_data(p1, p2, s_p1, s_p2, bt_p1, bt_2, dur, is_tournoi, name_tournament):
+    logger.info(f"Handling game data for players: {p1} vs {p2}")
     try:
         player_1 = get_or_create_player(p1)
         player_2 = get_or_create_player(p2)
+        logger.debug(f"Players created or retrieved: {player_1}, {player_2}")
 
-        print("CHAKU & THEOUCHE are the BEST")
         create_match(player_1, player_2, s_p1, s_p2, bt_p1, bt_2, dur, is_tournoi, name_tournament)
-        print("and ADRIANO is the PEST")
+        logger.info("Match created successfully")
 
         update_player_statistics(p1)
         update_player_statistics(p2)
-  
+        logger.info("Player statistics updated")
+
     except Exception as e:
-        print(f"Error in endfortheouche: {e}")
+        logger.error(f"Error in handle_game_data: {e}")
 
 def get_player_by_name(name):
+    logger.debug(f"Checking if player exists with name: {name}")
     exists = Player.objects.filter(name=name).exists()
+    logger.debug(f"Player exists: {exists}")
     return exists
 
-
 def get_player(name):
+    logger.debug(f"Retrieving player with name: {name}")
     return Player.objects.get(name=name)
 
-
 def get_or_create_player(name):
+    logger.info(f"Getting or creating player with name: {name}")
     player_exists = get_player_by_name(name)
     if not player_exists:
         player = create_player(name)
+        logger.info(f"Player created: {player}")
         return player
     else:
         player = get_player(name)
-        return player 
-
+        logger.info(f"Player retrieved: {player}")
+        return player
 
 def create_player(
-    name, 
-    total_match=0, 
-    total_win=0, 
-    p_win= None, 
-    m_score_match= None, 
-    m_score_adv_match= None, 
-    best_score=0, 
-    m_nbr_ball_touch= None, 
-    total_duration= None, 
-    m_duration= None, 
-    num_participated_tournaments=0, 
+    name,
+    total_match=0,
+    total_win=0,
+    p_win=None,
+    m_score_match=None,
+    m_score_adv_match=None,
+    best_score=0,
+    m_nbr_ball_touch=None,
+    total_duration=None,
+    m_duration=None,
+    num_participated_tournaments=0,
     num_won_tournaments=0
 ):
-    
+    logger.info(f"Creating player: {name}")
     player = Player(
         name=name,
         total_match=total_match,
@@ -69,14 +77,18 @@ def create_player(
         num_won_tournaments=num_won_tournaments
     )
     player.save()
+    logger.info(f"Player {name} saved successfully")
     return player
 
 def create_tournoi(name, nbr_player, date, winner):
+    logger.info(f"Creating tournament: {name}")
     tournoi = Tournoi(name=name, nbr_player=nbr_player, date=date, winner=winner)
     tournoi.save()
+    logger.info(f"Tournament {name} saved successfully")
     return tournoi
 
 def create_match(player1, player2, score_player1, score_player2, nbr_ball_touch_p1, nbr_ball_touch_p2, duration, is_tournoi, tournoi):
+    logger.info(f"Creating match between {player1.name} and {player2.name}")
     match = Match(
         player1=player1,
         player2=player2,
@@ -95,20 +107,22 @@ def create_match(player1, player2, score_player1, score_player2, nbr_ball_touch_
         match.winner = match.player2
     else:
         match.winner = None
-    
+
     match.save()
+    logger.info(f"Match saved successfully with winner: {match.winner.name if match.winner else 'None'}")
     return match
 
 def update_player_statistics(player_name):
+    logger.info(f"Updating statistics for player: {player_name}")
     player = get_object_or_404(Player, name=player_name)
 
     matches_as_player1 = Match.objects.filter(player1=player)
     matches_as_player2 = Match.objects.filter(player2=player)
 
     total_match = matches_as_player1.count() + matches_as_player2.count()
-    
-    # avoid dividing by 0
+
     if total_match == 0:
+        logger.warning(f"No matches found for player: {player_name}")
         player.total_match = total_match
         player.total_win = 0
         player.p_win = 0
@@ -121,22 +135,23 @@ def update_player_statistics(player_name):
         player.num_participated_tournaments = 0
         player.num_won_tournaments = 0
         player.save()
+        logger.info(f"Player statistics reset for {player_name}")
         return
-    
+
     won_matches = Match.objects.filter(winner=player)
     #part_tourn_as_p1 = Tournoi.objects.filter(matches__is_tournoi=True, matches__matches_as_player1=player)
     #part_tourn_as_p2 = Tournoi.objects.filter(matches__is_tournoi=True, matches__matches_as_player2=player)
-    #won_tourn = Tournoi.objects.filter(winner=player) 
+    #won_tourn = Tournoi.objects.filter(winner=player)
 
     total_score = matches_as_player1.aggregate(Sum('score_player1'))['score_player1__sum'] or 0
     total_score += matches_as_player2.aggregate(Sum('score_player2'))['score_player2__sum'] or 0
-    
+
     total_score_adv = matches_as_player1.aggregate(Sum('score_player2'))['score_player2__sum'] or 0
     total_score_adv += matches_as_player2.aggregate(Sum('score_player1'))['score_player1__sum'] or 0
 
     total_win = won_matches.count()
     p_win = (total_win / total_match) * 100
-    
+
     m_score_match = total_score / total_match
     m_score_adv_match = total_score_adv / total_match
 
@@ -151,7 +166,7 @@ def update_player_statistics(player_name):
     #total_tourn_p = part_tourn_as_p1.count() + part_tourn_as_p2.count()
     #total_win_tourn = won_tourn.count()
     #p_win_tourn = (total_win_tourn / total_tourn_p) * 100 if total_tourn_p else 0
- 
+
     best_score_as_player1 = matches_as_player1.aggregate(Max('score_player1'))['score_player1__max'] or 0
     best_score_as_player2 = matches_as_player2.aggregate(Max('score_player2'))['score_player2__max'] or 0
     best_score = max(best_score_as_player1, best_score_as_player2)
@@ -166,33 +181,12 @@ def update_player_statistics(player_name):
     player.total_duration = total_duration
     player.m_duration = m_duration
     # player.num_participated_tournaments = total_tourn_p
-    #player.num_won_tournaments = total_win_tourn 
+    #player.num_won_tournaments = total_win_tourn
 
     player.save()
+    logger.info(f"Statistics updated for player: {player_name}")
 
 def get_player_p_win(player_name):
+    logger.debug(f"Getting win percentage for player: {player_name}")
     player = get_object_or_404(Player, name=player_name)
     return player.p_win
-
-def create_tournament(name, nbr_player):
-    print("tournoi created!!!")
-    tournoi=Tournoi(name=name, nbr_player=nbr_player, winner=None)
-    tournoi.save()
-    print(f"tournoi name : {tournoi.name}  *******!*!*!*!**!*!**!*!*!*!*!*!*!*!*!*")
-    return tournoi
-
-def update_tournament(name_tournoi, winner_name):
-    tournoi = get_object_or_404(Tournoi, name=name_tournoi)
-    winner_p = get_object_or_404(Player, name=winner_name)
-    print(f"in update tourna - tournoi name : {tournoi.name}  *******!*!*!*!**!*!**!*!*!*!*!*!*!*!*!*")
-    print(f"in update tourna - winner is : {winner_p.name}  *******!*!*!*!**!*!**!*!*!*!*!*!*!*!*!*")
-
-    tournoi.winner = winner_p
-    print(f"in update tourna - TOURNOI winner is : {tournoi.winner.name}  *******!*!*!*!**!*!**!*!*!*!*!*!*!*!*!*")
-    tournoi.save()
-
-
-
-
-def getlen():
-    return Tournoi.objects.count()

pong/game/views.py

@@ -9,65 +9,111 @@ from django.contrib.auth.models import User
 from django.contrib.auth import authenticate
 from django.views.decorators.csrf import csrf_exempt
 from rest_framework import viewsets
+from django.db import transaction, IntegrityError
 
 import json
 import uuid
+import logging
+
+logger = logging.getLogger(__name__)
 
 def index(request):
+    logger.info("Accessing index view")
     return render(request, 'index.html')
 
 @csrf_exempt
 def check_user_exists(request):
     if request.method == 'POST':
+        logger.info("POST request received for checking user existence")
         data = json.loads(request.body)
         username = data.get('username')
         if User.objects.filter(username=username).exists():
+            logger.info(f"User {username} exists")
             return JsonResponse({'exists': True})
+        logger.info(f"User {username} does not exist")
         return JsonResponse({'exists': False})
+    logger.warning("Invalid request method for check_user_exists")
     return JsonResponse({'error': 'Invalid request method'}, status=400)
 
 @csrf_exempt
 def register_user(request):
-    if request.method == 'POST':
-        data = json.loads(request.body)
-        username = data.get('username')
-        password = data.get('password')
-        if not User.objects.filter(username=username).exists():
-            user = User.objects.create_user(username=username, password=password)
-            token = get_or_create_token(user)
-            return JsonResponse({'registered': True, 'token': token})
-        return JsonResponse({'registered': False, 'error': 'User already exists'})
-    return JsonResponse({'error': 'Invalid request method'}, status=400)
-
-@csrf_exempt
-def authenticate_user(request):
     if request.method == 'POST':
         try:
+            logger.info("Received POST request for user registration")
             data = json.loads(request.body)
-            username = data.get('username', '')
-            password = data.get('password', '')
-            user = authenticate(username=username, password=password)
-            if user is not None:
+            username = data.get('username')
+            password = data.get('password')
+
+            logger.info(f"Attempting to register user: {username}")
+
+            if not username or not password:
+                logger.warning("Username or password not provided")
+                return JsonResponse({'registered': False, 'error': 'Username and password are required'}, status=400)
+
+            with transaction.atomic():
+                user_exists = User.objects.select_for_update().filter(username=username).exists()
+
+                if user_exists:
+                    logger.warning(f"User {username} already exists")
+                    return JsonResponse({'registered': False, 'error': 'User already exists'}, status=409)
+
+                user = User.objects.create_user(username=username, password=password)
                 token = get_or_create_token(user)
-                return JsonResponse({'authenticated': True, 'token': token, 'user_id': user.id})
-            else:
-                return JsonResponse({'authenticated': False}, status=401)
+                logger.info(f"User {username} registered successfully")
+                return JsonResponse({'registered': True, 'token': token})
+
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON decode error: {str(e)}")
+            return JsonResponse({'error': 'Invalid JSON data'}, status=400)
+
+        except IntegrityError:
+            logger.error(f"IntegrityError: User {username} already exists")
+            return JsonResponse({'registered': False, 'error': 'User already exists'}, status=409)
+
         except Exception as e:
-            return JsonResponse({'error': str(e)}, status=500)
-    else:
-        return JsonResponse({'error': 'Method not allowed'}, status=405)
+            logger.error(f"Error in register_user: {str(e)}")
+            return JsonResponse({'error': f'Internal Server Error: {str(e)}'}, status=500)
+
+    logger.warning("Invalid request method for register_user")
+    return JsonResponse({'error': 'Invalid request method'}, status=405)
 
 def get_or_create_token(user):
+    logger.info(f"Generating or retrieving token for user: {user.username}")
     if not user.auth_token:
         while True:
             token = str(uuid.uuid4())
             if not User.objects.filter(auth_token=token).exists():
                 user.auth_token = token
                 user.save()
+                logger.info(f"Token generated for user {user.username}: {token}")
                 break
     return user.auth_token
 
+@csrf_exempt
+def authenticate_user(request):
+    if request.method == 'POST':
+        try:
+            logger.info("Received POST request for user authentication")
+            data = json.loads(request.body)
+            username = data.get('username', '')
+            password = data.get('password', '')
+            user = authenticate(username=username, password=password)
+            if user is not None:
+                token = get_or_create_token(user)
+                logger.info(f"User {username} authenticated successfully")
+                return JsonResponse({'authenticated': True, 'token': token, 'user_id': user.id})
+            else:
+                logger.warning(f"Authentication failed for user {username}")
+                return JsonResponse({'authenticated': False}, status=401)
+        except Exception as e:
+            logger.error(f"Error in authenticate_user: {str(e)}")
+            return JsonResponse({'error': str(e)}, status=500)
+    else:
+        logger.warning("Invalid request method for authenticate_user")
+        return JsonResponse({'error': 'Method not allowed'}, status=405)
+
 def match_list_json(request):
+    logger.info("Fetching match list")
     matches = Match.objects.all()
     data = {
         'matches': list(matches.values(
@@ -76,11 +122,13 @@ def match_list_json(request):
             'is_tournoi', 'tournoi__name'
         ))
     }
+    logger.info(f"Match list fetched successfully: {len(data['matches'])} matches found")
     return JsonResponse(data)
 
 def player_list_json(request):
+    logger.info("Fetching player list")
     players = Player.objects.all()
-    
+
     data = {
         'players': list(players.values(
             'id', 'name', 'total_match', 'total_win', 'p_win',
@@ -89,25 +137,30 @@ def player_list_json(request):
             'num_participated_tournaments', 'num_won_tournaments'
         ))
     }
+    logger.info(f"Player list fetched successfully: {len(data['players'])} players found")
     return JsonResponse(data)
 
-def get_tournoi_data(tournoi):
-    return {
-        "id": tournoi.id,
-        "name": tournoi.name,
-        "nbr_player": tournoi.nbr_player,
-        "date": tournoi.date,
-        "winner": {
-            "id": tournoi.winner.id,
-            "name": tournoi.winner.name
-        } if tournoi.winner else None
+def tournoi_list_json(request):
+    logger.info("Fetching tournoi list")
+    tournois = Tournoi.objects.all()
+
+    data = {
+        'tournois': list(tournois.values(
+            'id', 'name', 'nbr_player', 'date', 'winner'
+        ))
     }
+    logger.info(f"Tournoi list fetched successfully: {len(data['tournois'])} tournois found")
+    return JsonResponse(data)
 
 def tournoi_list_json(request):
-    tournois = Tournoi.objects.select_related('winner').all()  # Charge les données du gagnant
-    tournois_data = [get_tournoi_data(tournoi) for tournoi in tournois]
-    return JsonResponse({"tournois": tournois_data})
+    tournois = Tournoi.objects.all()
 
+    data = {
+        'tournois': list(tournois.values(
+            'id', 'name', 'nbr_player', 'date', 'winner'
+        ))
+    }
+    return JsonResponse(data)
 
 from web3 import Web3
 
@@ -145,7 +198,7 @@ def read_data(request):
         # print(f"Final Order: {', '.join(tournament[5])}")
     print("-----------------------------")
     return JsonResponse(json_data, safe=False)
-        
+
 
 def write_data(request):
     # addTournament(string,uint256,uint256,string[],string[])
@@ -173,4 +226,3 @@ def write_data(request):
     # tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
     # print("Transaction receipt:", tx_receipt)
     print("-----------------------------")
-