Update app.py

app.py

@@ -10,6 +10,7 @@ from psycopg2.extras import RealDictCursor
 from google import genai
 from google.genai import types
 from utils import load_prompt
+from datetime import datetime
 
 # --- Configuration de l'application ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -54,7 +55,7 @@ SAFETY_SETTINGS = [
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
 ]
 
-# --- Helpers de base de données (de l'exemple) ---
+# --- Helpers de base de données ---
 def create_connection():
     """Crée et retourne une connexion à la base de données PostgreSQL."""
     if not DATABASE_URL:
@@ -66,12 +67,68 @@ def create_connection():
         logging.error(f"Impossible de se connecter à la base de données : {e}")
         return None
 
-# --- Route Principale ---
+def init_database():
+    """Initialise la table de sauvegarde des dissertations si elle n'existe pas."""
+    conn = create_connection()
+    if not conn:
+        return False
+    try:
+        with conn.cursor() as cur:
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS dissertations (
+                    id SERIAL PRIMARY KEY,
+                    user_ip VARCHAR(45),
+                    user_agent TEXT,
+                    question TEXT NOT NULL,
+                    dissertation_type VARCHAR(10) NOT NULL,
+                    course_id INTEGER,
+                    course_title VARCHAR(255),
+                    generated_content JSONB,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    pdf_generated BOOLEAN DEFAULT FALSE
+                )
+            """)
+        conn.commit()
+        return True
+    except Exception as e:
+        logging.error(f"Erreur lors de l'initialisation de la base de données : {e}")
+        return False
+    finally:
+        if conn:
+            conn.close()
+
+def save_dissertation(user_ip, user_agent, question, dissertation_type, course_id, course_title, content):
+    """Sauvegarde une dissertation générée en base de données."""
+    conn = create_connection()
+    if not conn:
+        return None
+    try:
+        with conn.cursor() as cur:
+            cur.execute("""
+                INSERT INTO dissertations (user_ip, user_agent, question, dissertation_type, course_id, course_title, generated_content)
+                VALUES (%s, %s, %s, %s, %s, %s, %s)
+                RETURNING id
+            """, (user_ip, user_agent, question, dissertation_type, course_id, course_title, json.dumps(content)))
+        conn.commit()
+        return cur.fetchone()[0]
+    except Exception as e:
+        logging.error(f"Erreur lors de la sauvegarde de la dissertation : {e}")
+        return None
+    finally:
+        if conn:
+            conn.close()
+
+# --- Routes Principales ---
 @app.route('/')
 def philosophie():
     return render_template("philosophie.html")
 
-# --- NOUVELLE Route API pour lister les cours ---
+@app.route('/gestion')
+def gestion():
+    """Page de gestion pour afficher toutes les dissertations."""
+    return render_template("gestion.html")
+
+# --- Routes API ---
 @app.route('/api/philosophy/courses', methods=['GET'])
 def get_philosophy_courses():
     """Récupère la liste de tous les cours de philosophie pour le menu déroulant."""
@@ -90,7 +147,130 @@ def get_philosophy_courses():
         if conn:
             conn.close()
 
-# --- Route API pour la génération de dissertation (MODIFIÉE) ---
+@app.route('/api/dissertations', methods=['GET'])
+def get_dissertations():
+    """Récupère toutes les dissertations avec pagination."""
+    page = int(request.args.get('page', 1))
+    per_page = int(request.args.get('per_page', 10))
+    search = request.args.get('search', '').strip()
+    
+    conn = create_connection()
+    if not conn:
+        return jsonify({"error": "Connexion à la base de données échouée."}), 503
+    
+    try:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            # Construire la requête avec recherche optionnelle
+            base_query = """
+                SELECT d.*, COUNT(*) OVER() as total_count
+                FROM dissertations d
+            """
+            where_clause = ""
+            params = []
+            
+            if search:
+                where_clause = " WHERE d.question ILIKE %s OR d.course_title ILIKE %s"
+                params = [f"%{search}%", f"%{search}%"]
+            
+            query = base_query + where_clause + """
+                ORDER BY d.created_at DESC
+                LIMIT %s OFFSET %s
+            """
+            params.extend([per_page, (page - 1) * per_page])
+            
+            cur.execute(query, params)
+            results = cur.fetchall()
+            
+            total_count = results[0]['total_count'] if results else 0
+            dissertations = []
+            
+            for row in results:
+                dissertations.append({
+                    'id': row['id'],
+                    'user_ip': row['user_ip'],
+                    'user_agent': row['user_agent'],
+                    'question': row['question'],
+                    'dissertation_type': row['dissertation_type'],
+                    'course_id': row['course_id'],
+                    'course_title': row['course_title'],
+                    'created_at': row['created_at'].isoformat() if row['created_at'] else None,
+                    'pdf_generated': row['pdf_generated'],
+                    'content_preview': row['generated_content'].get('introduction', '')[:200] + '...' if row['generated_content'] else ''
+                })
+            
+            return jsonify({
+                'dissertations': dissertations,
+                'total': total_count,
+                'page': page,
+                'per_page': per_page,
+                'total_pages': (total_count + per_page - 1) // per_page
+            })
+            
+    except Exception as e:
+        logging.error(f"Erreur lors de la récupération des dissertations : {e}")
+        return jsonify({"error": "Erreur interne du serveur."}), 500
+    finally:
+        if conn:
+            conn.close()
+
+@app.route('/api/dissertations/<int:dissertation_id>', methods=['GET'])
+def get_dissertation_detail(dissertation_id):
+    """Récupère le détail complet d'une dissertation."""
+    conn = create_connection()
+    if not conn:
+        return jsonify({"error": "Connexion à la base de données échouée."}), 503
+    
+    try:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute("""
+                SELECT * FROM dissertations WHERE id = %s
+            """, (dissertation_id,))
+            result = cur.fetchone()
+            
+            if not result:
+                return jsonify({"error": "Dissertation non trouvée."}), 404
+            
+            return jsonify({
+                'id': result['id'],
+                'user_ip': result['user_ip'],
+                'user_agent': result['user_agent'],
+                'question': result['question'],
+                'dissertation_type': result['dissertation_type'],
+                'course_id': result['course_id'],
+                'course_title': result['course_title'],
+                'created_at': result['created_at'].isoformat() if result['created_at'] else None,
+                'pdf_generated': result['pdf_generated'],
+                'generated_content': result['generated_content']
+            })
+            
+    except Exception as e:
+        logging.error(f"Erreur lors de la récupération de la dissertation {dissertation_id} : {e}")
+        return jsonify({"error": "Erreur interne du serveur."}), 500
+    finally:
+        if conn:
+            conn.close()
+
+@app.route('/api/dissertations/<int:dissertation_id>', methods=['DELETE'])
+def delete_dissertation(dissertation_id):
+    """Supprime une dissertation."""
+    conn = create_connection()
+    if not conn:
+        return jsonify({"error": "Connexion à la base de données échouée."}), 503
+    
+    try:
+        with conn.cursor() as cur:
+            cur.execute("DELETE FROM dissertations WHERE id = %s", (dissertation_id,))
+            if cur.rowcount == 0:
+                return jsonify({"error": "Dissertation non trouvée."}), 404
+        conn.commit()
+        return jsonify({"message": "Dissertation supprimée avec succès."})
+    except Exception as e:
+        logging.error(f"Erreur lors de la suppression de la dissertation {dissertation_id} : {e}")
+        return jsonify({"error": "Erreur interne du serveur."}), 500
+    finally:
+        if conn:
+            conn.close()
+
 @app.route('/api/generate_dissertation', methods=['POST'])
 def generate_dissertation_api():
     if not client:
@@ -99,7 +279,7 @@ def generate_dissertation_api():
     data = request.json
     sujet = data.get('question', '').strip()
     dissertation_type = data.get('type', 'type1').strip()
-    course_id = data.get('courseId') # Nouvel ID de cours optionnel
+    course_id = data.get('courseId')
 
     if not sujet:
         return jsonify({"error": "Le champ 'question' est obligatoire."}), 400
@@ -109,19 +289,21 @@ def generate_dissertation_api():
 
     # Récupérer le contenu du cours si un ID est fourni
     context_str = ""
+    course_title = None
     if course_id:
         conn = create_connection()
         if not conn:
              return jsonify({"error": "Connexion à la base de données échouée pour récupérer le contexte."}), 503
         try:
             with conn.cursor(cursor_factory=RealDictCursor) as cur:
-                cur.execute("SELECT content FROM cours_philosophie WHERE id = %s", (course_id,))
+                cur.execute("SELECT title, content FROM cours_philosophie WHERE id = %s", (course_id,))
                 result = cur.fetchone()
-                if result and result.get('content'):
-                    context_str = f"\n\n--- EXTRAIT DE COURS À UTILISER COMME CONTEXTE PRINCIPAL ---\n{result['content']}"
+                if result:
+                    course_title = result['title']
+                    if result.get('content'):
+                        context_str = f"\n\n--- EXTRAIT DE COURS À UTILISER COMME CONTEXTE PRINCIPAL ---\n{result['content']}"
         except Exception as e:
             logging.error(f"Erreur lors de la récupération du contexte du cours {course_id}: {e}")
-            # On continue sans le contexte en cas d'erreur DB
         finally:
             if conn:
                 conn.close()
@@ -134,7 +316,6 @@ def generate_dissertation_api():
              logging.error(f"Fichier de prompt non trouvé : {prompt_filename}")
              return jsonify({"error": "Configuration du prompt introuvable pour ce type."}), 500
 
-        # Injecter le sujet ET le contexte dans le prompt
         final_prompt = prompt_template.format(phi_prompt=sujet, context=context_str)
 
         config = types.GenerateContentConfig(
@@ -150,7 +331,23 @@ def generate_dissertation_api():
         )
 
         if response.parsed:
-            return jsonify(response.parsed.dict())
+            # Sauvegarder en base de données
+            user_ip = request.environ.get('HTTP_X_FORWARDED_FOR', request.environ.get('REMOTE_ADDR', 'unknown'))
+            user_agent = request.headers.get('User-Agent', 'unknown')
+            
+            dissertation_id = save_dissertation(
+                user_ip=user_ip,
+                user_agent=user_agent,
+                question=sujet,
+                dissertation_type=dissertation_type,
+                course_id=course_id,
+                course_title=course_title,
+                content=response.parsed.dict()
+            )
+            
+            result = response.parsed.dict()
+            result['dissertation_id'] = dissertation_id
+            return jsonify(result)
         else:
             logging.error(f"Erreur de parsing de la réponse structurée. Réponse brute : {response.text}")
             return jsonify({"error": "Le modèle n'a pas pu générer une structure valide."}), 500
@@ -160,4 +357,5 @@ def generate_dissertation_api():
         return jsonify({"error": f"Une erreur est survenue avec le service IA : {e}"}), 500
 
 if __name__ == '__main__':
+    init_database()  # Initialiser la base de données au démarrage
     app.run(debug=True, port=5001)