correction main

main.py

@@ -1,72 +1,105 @@
-from fastapi import FastAPI, Depends, HTTPException, Header
-from fastapi.middleware.cors import CORSMiddleware
-from firebase_admin import auth, credentials, initialize_app
-from functools import wraps
-import firebase_admin
-import os
-import json
-from dotenv import load_dotenv
-
-# Charger les variables d'environnement
-load_dotenv()
-
-app = FastAPI()
-
-# Configuration CORS pour autoriser les requêtes depuis le frontend
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "http://localhost:5173", 
-        "https://junsen-ai.vercel.app",
-        # "https://huggingface.co"
-    ],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Initialiser Firebase avec les credentials depuis les variables d'environnement
-if os.getenv('FIREBASE_CREDENTIALS'):
-    cred_dict = json.loads(os.getenv('FIREBASE_CREDENTIALS'))
-    cred = credentials.Certificate(cred_dict)
-else:
-    # Fallback pour le développement local
-    cred = credentials.Certificate("serviceAccountKey.json")
-
-firebase_admin.initialize_app(cred)
-
-# Middleware pour vérifier le token Firebase
-async def verify_token(authorization: str = Header(...)):
-    try:
-        token = authorization.split("Bearer ")[1]
-        decoded_token = auth.verify_id_token(token)
-        return decoded_token
-    except Exception:
-        raise HTTPException(status_code=401, detail="Token invalide")
-
-# Décorateur pour restreindre l'accès en fonction des rôles
-def require_role(roles):
-    def decorator(func):
-        @wraps(func)
-        async def wrapper(*args, token=Depends(verify_token), **kwargs):
-            if token.get("role") not in roles:
-                raise HTTPException(status_code=403, detail="Accès non autorisé")
-            return await func(*args, **kwargs)
-        return wrapper
-    return decorator
-
-# Routes sécurisées
-@app.get("/api/protected/admin")
-@require_role(["admin"])
-async def admin_only():
-    return {"message": "Route admin"}
-
-@app.get("/api/protected/user")
-@require_role(["user", "admin"])
-async def user_route():
-    return {"message": "Route utilisateur"}
-
-# Route de test pour vérifier que le serveur fonctionne
-@app.get("/")
-async def root():
+from fastapi import FastAPI, Depends, HTTPException, Header
+from fastapi.middleware.cors import CORSMiddleware
+from firebase_admin import auth, credentials, initialize_app
+from functools import wraps
+import firebase_admin
+import os
+import json
+from dotenv import load_dotenv
+
+# Charger les variables d'environnement
+load_dotenv()
+
+app = FastAPI()
+
+# Configuration CORS pour autoriser les requêtes depuis le frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173", 
+        "http://localhost:8000", 
+        "https://junsen-ai.vercel.app",
+        "https://2nzi-backendjunsen.hf.space"
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+# Décorateur pour restreindre l'accès en fonction des rôles
+def require_role(roles):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, token=Depends(verify_token), **kwargs):
+            print("Token dans require_role:", token)
+            print("Rôle requis:", roles)
+            print("Rôle trouvé:", token.get("role"))
+            if token.get("role") not in roles:
+                raise HTTPException(
+                    status_code=403,
+                    detail={"message": "Accès non autorisé", "role": token.get("role")}
+                )
+            return await func(*args, **kwargs)
+        return wrapper
+    return decorator
+# Initialiser Firebase avec les credentials depuis les variables d'environnement
+if os.getenv('FIREBASE_CREDENTIALS'):
+    cred_dict = json.loads(os.getenv('FIREBASE_CREDENTIALS'))
+    cred = credentials.Certificate(cred_dict)
+else:
+    # Fallback pour le développement local
+    cred = credentials.Certificate("serviceAccountKey.json")
+
+firebase_admin.initialize_app(cred)
+
+async def verify_token(authorization: str = Header(...)):
+    try:
+        print("Authorization reçu:", authorization[:50] + "...")
+        token = authorization.split("Bearer ")[1]
+        print("Token extrait:", token[:50] + "...")
+        decoded_token = auth.verify_id_token(token)
+        
+        # Récupérer les custom claims ou le rôle depuis Firestore
+        try:
+            user = auth.get_user(decoded_token['uid'])
+            print("User data:", user._data)
+        except Exception as e:
+            print("Erreur lors de la récupération des données utilisateur:", str(e))
+        
+        return decoded_token
+    except Exception as e:
+        print("Erreur de vérification:", str(e))
+        raise HTTPException(
+            status_code=401,
+            detail={
+                "message": "Token invalide",
+                "error": str(e)
+            }
+        )
+
+@app.get("/api/protected/user")
+@require_role(["user_extern", "admin"])
+async def user_route():
+    try:
+        return {"message": "Route utilisateur"}
+    except Exception as e:
+        print("Erreur dans user_route:", str(e))
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "message": "Erreur serveur",
+                "error": str(e)
+            }
+        )
+
+
+
+# Routes sécurisées
+@app.get("/api/protected/admin")
+@require_role(["admin"])
+async def admin_only():
+    return {"message": "Route admin"}
+
+# Route de test pour vérifier que le serveur fonctionne
+@app.get("/")
+async def root():
     return {"message": "Backend Junsen AI opérationnel"}