Update server.py

server.py

@@ -5,7 +5,6 @@ from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 import json
-import asyncio
 import uvicorn
 from typing import Dict, Set, Optional, Any
 import logging
@@ -38,32 +37,16 @@ except FileNotFoundError:
     maps_data = {}
 
 
-# Pfad zur statischen index.html-Datei
-STATIC_INDEX_PATH = os.path.join("static", "map.html")
-
-@app.get("/", response_class=FileResponse) # <-- Geändert: FileResponse
+@app.get("/", response_class=FileResponse)  # <-- Geändert: FileResponse
 async def read_index(request: Request):
-    # Stellt sicher, dass die index.html existiert
-    if not os.path.exists(STATIC_INDEX_PATH):
-        # Fallback auf das Template, falls die statische Datei nicht existiert
-        # Du könntest auch einen HTTPException werfen, wenn die Datei obligatorisch ist
-        return templates.TemplateResponse("index.html", {"request": request, "maps": maps_data})
-    return STATIC_INDEX_PATH # <-- Geändert: Pfad zur Datei
-
-@app.get("/map/{normalized_name}", response_class=FileResponse) # <-- Geändert: FileResponse
-async def get_map_by_normalized_name(request: Request, normalized_name: str):
-     # Optional: Validierung, ob normalized_name prinzipiell gültig ist
-     # map_entry = maps_data.get(normalized_name)
-     # if not map_entry and normalized_name != "": # Entferne diese Zeile, da wir immer die SPA servieren
-     #    raise HTTPException(status_code=404, detail="Map not found") # Entferne diese Zeile
+    return templates.TemplateResponse("map.html", {"request": request, "maps": maps_data})
 
-    # Stellt sicher, dass die index.html existiert
-    if not os.path.exists(STATIC_INDEX_PATH):
-         # Fallback auf das Template, falls die statische Datei nicht existiert
-        map_entry = maps_data.get(normalized_name)
-        filtered_maps = [map_entry] if map_entry else []
-        return templates.TemplateResponse("map.html", {"request": request, "maps": filtered_maps})
-    return STATIC_INDEX_PATH # <-- Geändert: Immer die statische index.html zurückgeben
+
+@app.get("/map/{normalized_name}", response_class=FileResponse)  # <-- Geändert: FileResponse
+async def get_map_by_normalized_name(request: Request, normalized_name: str):
+    map_entry = maps_data.get(normalized_name)
+    filtered_maps = [map_entry] if map_entry else []
+    return templates.TemplateResponse("map.html", {"request": request, "maps": filtered_maps})
 
 
 # Neuer API-Endpunkt für Map-Daten
@@ -74,7 +57,8 @@ async def get_map_data(map_name: str):
     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]] = {}
@@ -96,7 +80,7 @@ class ConnectionManager:
     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
@@ -112,21 +96,21 @@ class ConnectionManager:
             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
         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)
+        is_first_client = self.group_leaders.get(group_name) == websocket
         client_info = {
-            "type": "joined", 
-            "group": group_name, 
+            "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"
+            "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
 
@@ -156,7 +140,7 @@ class ConnectionManager:
                 # Optional: Nachricht an bestimmten Client ausschließen
                 if connection == exclude:
                     continue
-                    
+
                 try:
                     await connection.send_text(message)
                     self.message_stats["total_sent"] += 1
@@ -169,31 +153,20 @@ 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
-        }
+            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()
@@ -218,19 +191,15 @@ async def websocket_endpoint(websocket: WebSocket):
                         join_info = await manager.join_group(websocket, group_name, client_type)
                         # Bestätigungsmessage
                         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"
+                            "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
-                        )
+                        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))
@@ -279,4 +248,4 @@ async def get_group_info(group_name: str):
 
 
 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")