update main

main.py

@@ -1,105 +1,78 @@
-from fastapi import FastAPI, Depends, HTTPException, Header
+from fastapi import FastAPI, Depends, HTTPException, status, Response
 from fastapi.middleware.cors import CORSMiddleware
-from firebase_admin import auth, credentials, initialize_app
-from functools import wraps
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from firebase_admin import auth, credentials, firestore
 import firebase_admin
-import os
-import json
-from dotenv import load_dotenv
 
-# Charger les variables d'environnement
-load_dotenv()
+# Initialisation Firebase Admin
+cred = credentials.Certificate("serviceAccountKey.json")
+firebase_admin.initialize_app(cred)
+db = firestore.client()
 
 app = FastAPI()
 
-# Configuration CORS pour autoriser les requêtes depuis le frontend
+# Configuration CORS
+allowed_origins = [
+    "http://localhost:5173"
+]
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=[
-        "http://localhost:5173", 
-        "http://localhost:8000", 
-        "https://junsen-ai.vercel.app",
-        "https://2nzi-backendjunsen.hf.space"
-    ],
+    allow_origins=allowed_origins,
     allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_methods=["POST", "GET"],
+    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(...)):
+# Fonction pour vérifier le token Firebase et récupérer le rôle depuis Firestore
+def get_user(res: Response,
+             cred: HTTPAuthorizationCredentials = Depends(HTTPBearer(auto_error=False))):
+    if cred is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Bearer authentication required",
+            headers={'WWW-Authenticate': 'Bearer realm="auth_required"'},
+        )
     try:
-        print("Authorization reçu:", authorization[:50] + "...")
-        token = authorization.split("Bearer ")[1]
-        print("Token extrait:", token[:50] + "...")
-        decoded_token = auth.verify_id_token(token)
+        # Vérification et décodage du token Firebase
+        decoded_token = auth.verify_id_token(cred.credentials)
+        user_id = decoded_token['uid']
+        
+        # Récupération du rôle de l'utilisateur depuis Firestore
+        user_doc = db.collection('users').document(user_id).get()
+        if not user_doc.exists:
+            raise HTTPException(status_code=401, detail="Utilisateur non trouvé dans Firestore")
         
-        # 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))
+        # Extraction du rôle et ajout aux informations utilisateur
+        user_data = user_doc.to_dict()
+        user_role = user_data.get('role', 'user_extern')  # Par défaut à 'user_extern' si le rôle n'existe pas
+        decoded_token['role'] = user_role
+        res.headers['WWW-Authenticate'] = 'Bearer realm="auth_required"'
         
         return decoded_token
-    except Exception as e:
-        print("Erreur de vérification:", str(e))
+    except Exception as err:
         raise HTTPException(
-            status_code=401,
-            detail={
-                "message": "Token invalide",
-                "error": str(e)
-            }
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Invalid authentication credentials. {err}",
+            headers={'WWW-Authenticate': 'Bearer error="invalid_token"'},
         )
 
-@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)
-            }
-        )
+# Fonction de dépendance pour vérifier le rôle
+def require_role(allowed_roles):
+    def role_checker(user_info=Depends(get_user)):
+        if user_info['role'] not in allowed_roles:
+            raise HTTPException(status_code=403, detail="Accès non autorisé")
+        return user_info
+    return role_checker
 
+# Route publique
+@app.get("/")
+async def root():
+    return {"message": "This is the root."}
 
+@app.get("/api/protected/user")
+async def protected_user_route(user_info=Depends(get_user)):
+    return {"message": "Protected user route accessed successfully", "user_info": user_info}
 
-# 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"}
+async def protected_admin_route(user_info=Depends(require_role(["admin"]))):
+    return {"message": "Protected admin route accessed successfully", "user_info": user_info}