Update server_old.py

server_old.py

@@ -11,13 +11,13 @@ app = FastAPI()
 # Configure CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins
+    allow_origins=["*"],
     allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods
-    allow_headers=["*"],  # Allows all headers
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
-# Serve static files from the "static" directory
+# Serve static files
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 # Set up Jinja2 templates
@@ -44,40 +44,90 @@ async def get_map_by_normalized_name(request: Request, normalized_name: str):
 
 class ConnectionManager:
     def __init__(self):
-        self.active_connections: list[WebSocket] = []
+        self.groups: dict[str, set[WebSocket]] = {}
+        self.connections: dict[WebSocket, str] = {}
 
     async def connect(self, websocket: WebSocket):
         await websocket.accept()
-        self.active_connections.append(websocket)
-        print("active_connections:", self.active_connections)
 
     def disconnect(self, websocket: WebSocket):
-        self.active_connections.remove(websocket)
-        print("active_connections:", self.active_connections)
-
-    async def send_personal_message(self, message: str, websocket: WebSocket):
-        await websocket.send_text(message)
-
-    async def broadcast(self, message: str):
-        for connection in self.active_connections:
-            # print(f"Broadcast: {message}")
-            await connection.send_text(message)
+        if websocket in self.connections:
+            group_name = self.connections[websocket]
+            self.remove_from_group(websocket, group_name)
+
+    async def join_group(self, websocket: WebSocket, group_name: str):
+        # Remove from previous group if exists
+        if websocket in self.connections:
+            old_group = self.connections[websocket]
+            self.remove_from_group(websocket, old_group)
+        
+        # Add to new group
+        if group_name not in self.groups:
+            self.groups[group_name] = set()
+        self.groups[group_name].add(websocket)
+        self.connections[websocket] = group_name
+        print(f"Client joined group '{group_name}'")
+
+    def remove_from_group(self, websocket: WebSocket, group_name: str):
+        if group_name in self.groups and websocket in self.groups[group_name]:
+            self.groups[group_name].remove(websocket)
+            if len(self.groups[group_name]) == 0:
+                del self.groups[group_name]
+                print(f"Group '{group_name}' deleted (no members)")
+        if websocket in self.connections:
+            del self.connections[websocket]
+        print(f"Client removed from group '{group_name}'")
+
+    async def broadcast_to_group(self, message: str, group_name: str):
+        if group_name in self.groups:
+            for connection in self.groups[group_name]:
+                await connection.send_text(message)
 
 
 manager = ConnectionManager()
 
 
-@app.websocket("/{client_id}")
-async def websocket_endpoint(websocket: WebSocket, client_id: int):
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
     await manager.connect(websocket)
     try:
         while True:
             data = await websocket.receive_text()
-            await manager.broadcast(data)  # Direktes Broadcasten der Daten
+            try:
+                message = json.loads(data)
+                # Handle join messages
+                if message.get('type') == 'join':
+                    group_name = message.get('group')
+                    if group_name:
+                        await manager.join_group(websocket, group_name)
+                    else:
+                        error = json.dumps({
+                            "type": "error",
+                            "message": "Missing group name in join request"
+                        })
+                        await websocket.send_text(error)
+                
+                # Broadcast all other messages to the group
+                else:
+                    if websocket in manager.connections:
+                        group_name = manager.connections[websocket]
+                        await manager.broadcast_to_group(data, group_name)
+                    else:
+                        error = json.dumps({
+                            "type": "error",
+                            "message": "Join a group before sending messages"
+                        })
+                        await websocket.send_text(error)
+            
+            except json.JSONDecodeError:
+                # Handle non-JSON messages by broadcasting directly
+                if websocket in manager.connections:
+                    group_name = manager.connections[websocket]
+                    await manager.broadcast_to_group(data, group_name)
+    
     except WebSocketDisconnect:
         manager.disconnect(websocket)
-        await manager.broadcast(json.dumps({"type": "client_info", "data": f"Client #{client_id} left the chat"}))
 
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000)