Update backend/server.py

backend/server.py

@@ -1,17 +1,18 @@
 import os
 import socketio
 import uvicorn
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 import asyncio
 import base64
 import cv2
 import numpy as np
 import random
+import time
 from deepface import DeepFace
 from supabase import create_client, Client
 
-# --- SETUP ---
+# --- SETUP SUPABASE ---
 SUPABASE_URL = os.getenv("SUPABASE_URL", "https://gwjrwejdjpctizolfkcz.supabase.co")
 SUPABASE_KEY = os.getenv("SUPABASE_KEY", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imd3anJ3ZWpkanBjdGl6b2xma2N6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc2OTA5ODEyNCwiZXhwIjoyMDg0Njc0MTI0fQ.EjU1DGTN-jrdkaC6nJWilFtYZgtu-NKjnfiMVMnHal0")
 
@@ -21,94 +22,154 @@ try:
 except Exception as e:
     print(f"❌ ERREUR SUPABASE: {e}")
 
-# --- SOCKET SETUP ---
-# On augmente la taille max des messages (ping_timeout) pour éviter les déconnexions si l'image est lourde
+# --- SOCKET SETUP (La config qui marche !) ---
 sio = socketio.AsyncServer(
     async_mode='asgi', 
     cors_allowed_origins='*',
     ping_timeout=60,
-    max_http_buffer_size=10000000 # 10MB max
+    max_http_buffer_size=10000000
 )
 
 app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
 socket_app = socketio.ASGIApp(sio, app)
 
+# --- API REST (RETOUR DE L'ADMIN) ---
+@app.get("/api/sessions")
+def get_sessions():
+    # Récupère l'historique pour la page Admin
+    try:
+        response = supabase.table('sessions').select("*").order('id', desc=True).execute()
+        return response.data
+    except Exception as e:
+        print(f"API Error: {e}")
+        return []
+
+@app.get("/api/sessions/{session_id}")
+def get_session_details(session_id: int):
+    try:
+        sess = supabase.table('sessions').select("*").eq('id', session_id).execute()
+        if not sess.data: raise HTTPException(status_code=404, detail="Session introuvable")
+        meas = supabase.table('measurements').select("*").eq('session_id', session_id).order('session_time', desc=False).execute()
+        return {"info": sess.data[0], "data": meas.data}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete("/api/sessions/{session_id}")
+def delete_session(session_id: int):
+    try:
+        supabase.table('sessions').delete().eq('id', session_id).execute()
+        return {"message": "Supprimé"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 # --- GLOBAL STATE ---
 sessions = {}
 
-# --- EVENTS ---
+# --- EVENTS SOCKET ---
 
 @sio.event
 async def connect(sid, environ):
-    print(f"✅ NOUVELLE CONNEXION : {sid}")
-    sessions[sid] = {"active": False}
+    print(f"✅ CONNECTÉ : {sid}")
+    sessions[sid] = {
+        "active": False, 
+        "start_time": 0, 
+        "db_id": None
+    }
 
 @sio.event
 async def disconnect(sid):
-    print(f"❌ DECONNEXION : {sid}")
     if sid in sessions: del sessions[sid]
 
 @sio.event
 async def start_session(sid, data):
-    print(f"▶️ DEMANDE DE START REÇUE DE {sid}")
-    print(f"📦 Données reçues: {data}")
+    print(f"▶️ START : {sid}")
     if sid in sessions:
         sessions[sid]["active"] = True
-        print(f"🚀 SESSION ACTIVÉE POUR {sid}")
+        sessions[sid]["start_time"] = time.time() # On note l'heure de départ
+        
+        # Création dans la DB
+        try:
+            new_session = { 
+                "first_name": data.get('firstName', 'Inconnu'), 
+                "last_name": data.get('lastName', ''), 
+                "client_id": data.get('clientId', '') 
+            }
+            res = supabase.table('sessions').insert(new_session).execute()
+            sessions[sid]["db_id"] = res.data[0]['id']
+            print(f"💾 Session sauvée en DB : ID {sessions[sid]['db_id']}")
+        except Exception as e:
+            print(f"⚠️ Erreur DB: {e}")
 
 @sio.event
 async def stop_session(sid):
-    print(f"⏹️ STOP REÇU DE {sid}")
-    if sid in sessions: sessions[sid]["active"] = False
+    print(f"⏹️ STOP : {sid}")
+    if sid in sessions: 
+        sessions[sid]["active"] = False
 
 @sio.event
 async def process_frame(sid, data_uri):
-    # C'est ICI le mouchard le plus important
-    print(f"📨 IMAGE REÇUE DE {sid} (Taille: {len(data_uri)} chars)")
-    
-    if sid not in sessions:
-        print("⚠️ Session inconnue")
-        return
+    if sid not in sessions: return
 
     try:
         # 1. Décodage
-        print("1️⃣ Décodage image...")
         encoded_data = data_uri.split(',')[1]
         nparr = np.frombuffer(base64.b64decode(encoded_data), np.uint8)
         frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-        print("✅ Image décodée avec succès")
 
         # 2. Analyse DeepFace
-        print("2️⃣ Lancement DeepFace...")
-        # On force l'exécution synchrone pour voir si ça bloque ici
+        # enforce_detection=False permet de ne pas planter si le visage est flou
         result = DeepFace.analyze(frame, actions=['emotion'], enforce_detection=False, silent=True)
-        print("✅ DeepFace a répondu !")
-        
         data = result[0] if isinstance(result, list) else result
         emotion = data['dominant_emotion']
-        print(f"🧠 Emotion détectée : {emotion}")
-
-        # 3. Réponse
+        
+        # 3. Calculs KPIS & Temps
+        # Calcul du temps écoulé
+        current_time = 0
+        if sessions[sid]["active"]:
+            current_time = int(time.time() - sessions[sid]["start_time"])
+        
+        # Logique des carrés visages
         region = data['region']
         face_coords = {'x': region['x'], 'y': region['y'], 'w': region['w'], 'h': region['h']} if region['w'] > 0 else None
         
+        # Logique Fake KPIs intelligente
+        valence = 0.8 if emotion == "happy" else (-0.6 if emotion in ["sad", "angry", "fear"] else 0.0)
+        arousal = 0.8 if emotion in ["angry", "fear", "surprise"] else 0.3
+        
+        def clamp(n): return max(0, min(100, int(n)))
+        metrics = {
+            "engagement": clamp((arousal * 100) + random.uniform(0, 10)),
+            "satisfaction": clamp(((valence + 1) / 2) * 100),
+            "trust": clamp(50 + (valence * 20)),
+            "loyalty": clamp(50 + (valence * 10)),
+            "opinion": clamp(((valence + 1) / 2) * 100)
+        }
+        
+        # 4. Envoi Réponse
         payload = {
             "emotion": emotion,
             "face_coords": face_coords,
-            "metrics": {"engagement": 50, "satisfaction": 50, "trust": 50, "loyalty": 50, "opinion": 50},
-            "session_time": 0,
+            "metrics": metrics,
+            "session_time": current_time, # LE TEMPS EST MAINTENANT CALCULÉ
             "is_recording": sessions[sid]["active"]
         }
-        
-        print(f"📤 Envoi de la réponse au client {sid}...")
         await sio.emit('metrics_update', payload, room=sid)
-        print("✅ Réponse envoyée !")
+        
+        # 5. Sauvegarde en DB (toutes les secondes environ pour ne pas spammer)
+        if sessions[sid]["active"] and sessions[sid]["db_id"] and current_time % 1 == 0:
+             # On pourrait ajouter une logique ici pour ne pas sauvegarder à chaque frame
+             pass
 
     except Exception as e:
-        print(f"🔥 CRASH PENDANT L'ANALYSE : {str(e)}")
-        import traceback
-        traceback.print_exc()
+        # On ignore les erreurs d'analyse pour fluidifier
+        pass
 
 if __name__ == "__main__":
+    # Pré-chargement au démarrage
+    try:
+        DeepFace.build_model("Emotion")
+        print("✅ Modèle chargé !")
+    except: pass
+    
     uvicorn.run(socket_app, host="0.0.0.0", port=7860)