Update server.py

server.py

@@ -1,12 +1,12 @@
-from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect, status
+from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect, status, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 import json
 import asyncio
 import uvicorn
-from typing import Dict, Set
+from typing import Dict, Set, Optional, Any
 import logging
 
 # Logging konfigurieren
@@ -49,11 +49,23 @@ async def get_map_by_normalized_name(request: Request, normalized_name: str):
     return templates.TemplateResponse("map.html", {"request": request, "maps": filtered_maps})
 
 
+# Neuer API-Endpunkt für Map-Daten
+@app.get("/api/map/{map_name}")
+async def get_map_data(map_name: str):
+    """API-Endpunkt zum Abrufen von Kartendaten"""
+    map_entry = maps_data.get(map_name)
+    if not map_entry:
+        raise HTTPException(status_code=404, detail="Map not found")
+    return JSONResponse(content=map_entry)
+
+
 class ConnectionManager:
     def __init__(self):
         self.groups: Dict[str, Set[WebSocket]] = {}
         self.connections: Dict[WebSocket, str] = {}
+        self.client_types: Dict[WebSocket, str] = {}  # Neue Speicherung für Client-Typen
         self.message_stats = {"total_sent": 0, "total_received": 0}
+        self.group_leaders: Dict[str, WebSocket] = {}  # Speichert den ersten Client jeder Gruppe
 
     async def connect(self, websocket: WebSocket):
         await websocket.accept()
@@ -65,7 +77,15 @@ class ConnectionManager:
             self.remove_from_group(websocket, group_name)
             logger.info(f"Client disconnected from group '{group_name}'")
 
-    async def join_group(self, websocket: WebSocket, group_name: str):
+    async def join_group(self, websocket: WebSocket, group_name: str, client_type: str = "web"):
+        """
+        Client einer Gruppe hinzufügen
+        
+        Args:
+            websocket: WebSocket-Verbindung
+            group_name: Name der Gruppe
+            client_type: Typ des Clients ("monitor" oder "web")
+        """
         # Remove from previous group if exists
         if websocket in self.connections:
             old_group = self.connections[websocket]
@@ -74,24 +94,53 @@ class ConnectionManager:
         # Add to new group
         if group_name not in self.groups:
             self.groups[group_name] = set()
+            self.group_leaders[group_name] = websocket  # Erster Client ist der Gruppenleiter
+            logger.info(f"Neue Gruppe '{group_name}' erstellt von {client_type}-Client")
+        
         self.groups[group_name].add(websocket)
         self.connections[websocket] = group_name
-        logger.info(f"Client joined group '{group_name}' (Total groups: {len(self.groups)})")
+        self.client_types[websocket] = client_type  # Speichere den Client-Typ
+        
+        # Prüfe ob dies der erste Client in der Gruppe ist
+        is_first_client = (self.group_leaders.get(group_name) == websocket)
+        client_info = {
+            "type": "joined", 
+            "group": group_name, 
+            "client_type": client_type,
+            "is_first": is_first_client,
+            "message": f"Erfolgreich Gruppe '{group_name}' beigetreten als {client_type}-Client"
+        }
+        
+        logger.info(f"Client ({client_type}) joined group '{group_name}' (First: {is_first_client})")
+        return client_info
 
     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 not self.groups[group_name]:  # Leere Gruppen entfernen
+            # Wenn der Gruppenleiter sich trennt, wähle einen neuen
+            if self.group_leaders.get(group_name) == websocket and self.groups[group_name]:
+                # Wähle den nächsten Client als neuen Leiter
+                self.group_leaders[group_name] = next(iter(self.groups[group_name]))
+                logger.info(f"Neuer Gruppenleiter für '{group_name}' gewählt")
+            elif not self.groups[group_name]:  # Leere Gruppen entfernen
                 del self.groups[group_name]
+                if group_name in self.group_leaders:
+                    del self.group_leaders[group_name]
                 logger.info(f"Group '{group_name}' deleted (no members)")
 
         if websocket in self.connections:
             del self.connections[websocket]
+        if websocket in self.client_types:
+            del self.client_types[websocket]
 
-    async def broadcast_to_group(self, message: str, group_name: str):
+    async def broadcast_to_group(self, message: str, group_name: str, exclude: Optional[WebSocket] = None):
         if group_name in self.groups:
             disconnected = set()
             for connection in self.groups[group_name].copy():  # Kopie für sichere Iteration
+                # Optional: Nachricht an bestimmten Client ausschließen
+                if connection == exclude:
+                    continue
+                    
                 try:
                     await connection.send_text(message)
                     self.message_stats["total_sent"] += 1
@@ -104,7 +153,31 @@ class ConnectionManager:
                 self.disconnect(conn)
 
     def get_stats(self):
-        return {"active_groups": len(self.groups), "total_connections": len(self.connections), **self.message_stats}
+        return {
+            "active_groups": len(self.groups), 
+            "total_connections": len(self.connections), 
+            **self.message_stats
+        }
+
+    def get_group_info(self, group_name: str) -> Dict[str, Any]:
+        """Gibt Informationen über eine Gruppe zurück"""
+        if group_name not in self.groups:
+            return {"group": group_name, "members": 0, "clients": []}
+            
+        members = []
+        for ws in self.groups[group_name]:
+            client_type = self.client_types.get(ws, "unknown")
+            is_leader = (self.group_leaders.get(group_name) == ws)
+            members.append({
+                "client_type": client_type,
+                "is_leader": is_leader
+            })
+            
+        return {
+            "group": group_name,
+            "members": len(members),
+            "clients": members
+        }
 
 
 manager = ConnectionManager()
@@ -124,10 +197,24 @@ async def websocket_endpoint(websocket: WebSocket):
                 # Handle join messages
                 if message.get("type") == "join":
                     group_name = message.get("group")
+                    client_type = message.get("client_type", "web")  # Standard: web
                     if group_name:
-                        await manager.join_group(websocket, group_name)
+                        join_info = await manager.join_group(websocket, group_name, client_type)
                         # Bestätigungsmessage
-                        await websocket.send_text(json.dumps({"type": "joined", "group": group_name, "message": f"Erfolgreich Gruppe '{group_name}' beigetreten"}))
+                        await websocket.send_text(json.dumps(join_info))
+                        
+                        # Benachrichtige andere Gruppenmitglieder über neuen Client
+                        notification = {
+                            "type": "client_joined",
+                            "group": group_name,
+                            "client_type": client_type,
+                            "message": f"Neuer {client_type}-Client ist der Gruppe beigetreten"
+                        }
+                        await manager.broadcast_to_group(
+                            json.dumps(notification), 
+                            group_name, 
+                            exclude=websocket  # Sende nicht an den neu verbundenen Client
+                        )
                     else:
                         error_msg = {"type": "error", "message": "Missing group name in join request"}
                         await websocket.send_text(json.dumps(error_msg))
@@ -165,5 +252,15 @@ async def health_check():
     return {"status": "healthy", "websocket_stats": manager.get_stats()}
 
 
+# Neuer Endpoint für Gruppeninformationen
+@app.get("/api/group/{group_name}")
+async def get_group_info(group_name: str):
+    """API-Endpunkt zum Abrufen von Gruppeninformationen"""
+    group_info = manager.get_group_info(group_name)
+    if group_info["members"] == 0:
+        raise HTTPException(status_code=404, detail="Group not found")
+    return JSONResponse(content=group_info)
+
+
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")