Update app.py

app.py

@@ -2,6 +2,7 @@
 import os
 import logging
 import json
+from datetime import datetime
 from flask import Flask, jsonify, render_template, request
 from pydantic import BaseModel, Field
 from typing import List, Optional
@@ -20,6 +21,13 @@ app.secret_key = os.environ.get("FLASK_SECRET_KEY", "un-secret-par-defaut")
 DATABASE_URL = os.environ.get("DATABASE")
 GOOGLE_API_KEY = os.environ.get("TOKEN")
 
+# Dossier pour stocker les données de gestion
+DATA_DIR = "data"
+DISSERTATIONS_FILE = os.path.join(DATA_DIR, "dissertations_log.json")
+
+# Créer le dossier data s'il n'existe pas
+os.makedirs(DATA_DIR, exist_ok=True)
+
 # --- Modèles de Données Pydantic (inchangés) ---
 class Argument(BaseModel):
     paragraphe_argumentatif: str = Field(description="Un unique paragraphe formant un argument complet. Il doit commencer par un connecteur logique (ex: 'Premièrement,'), suivi de son développement.")
@@ -66,11 +74,140 @@ def create_connection():
         logging.error(f"Impossible de se connecter à la base de données : {e}")
         return None
 
+# --- Helpers pour la gestion des données ---
+def save_dissertation_data(input_data, output_data, success=True, error_message=None):
+    """Sauvegarde les données d'entrée et de sortie dans un fichier JSON."""
+    try:
+        # Lire les données existantes
+        if os.path.exists(DISSERTATIONS_FILE):
+            with open(DISSERTATIONS_FILE, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+        else:
+            data = []
+        
+        # Préparer le nouvel enregistrement
+        record = {
+            "timestamp": datetime.now().isoformat(),
+            "input": {
+                "question": input_data.get('question', ''),
+                "type": input_data.get('type', ''),
+                "courseId": input_data.get('courseId')
+            },
+            "output": output_data if success else None,
+            "success": success,
+            "error": error_message,
+            "id": len(data) + 1
+        }
+        
+        # Ajouter le nouvel enregistrement
+        data.append(record)
+        
+        # Sauvegarder
+        with open(DISSERTATIONS_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+            
+    except Exception as e:
+        logging.error(f"Erreur lors de la sauvegarde des données: {e}")
+
+def load_dissertations_data():
+    """Charge toutes les données des dissertations depuis le fichier JSON."""
+    try:
+        if os.path.exists(DISSERTATIONS_FILE):
+            with open(DISSERTATIONS_FILE, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return []
+    except Exception as e:
+        logging.error(f"Erreur lors du chargement des données: {e}")
+        return []
+
 # --- Route Principale ---
 @app.route('/')
 def philosophie():
     return render_template("philosophie.html")
 
+# --- Route de Gestion ---
+@app.route('/gestion')
+def gestion():
+    return render_template("gestion.html")
+
+# --- API pour récupérer les données de gestion ---
+@app.route('/api/gestion/dissertations', methods=['GET'])
+def get_dissertations_data():
+    """Récupère toutes les données des dissertations générées."""
+    try:
+        data = load_dissertations_data()
+        return jsonify({
+            "success": True,
+            "data": data,
+            "total": len(data)
+        })
+    except Exception as e:
+        logging.error(f"Erreur lors de la récupération des données de gestion: {e}")
+        return jsonify({
+            "success": False,
+            "error": "Erreur lors de la récupération des données"
+        }), 500
+
+# --- API pour supprimer une entrée ---
+@app.route('/api/gestion/dissertations/<int:record_id>', methods=['DELETE'])
+def delete_dissertation_record(record_id):
+    """Supprime un enregistrement spécifique."""
+    try:
+        data = load_dissertations_data()
+        
+        # Trouver l'index de l'enregistrement à supprimer
+        record_index = None
+        for i, record in enumerate(data):
+            if record.get('id') == record_id:
+                record_index = i
+                break
+        
+        if record_index is None:
+            return jsonify({
+                "success": False,
+                "error": "Enregistrement non trouvé"
+            }), 404
+        
+        # Supprimer l'enregistrement
+        deleted_record = data.pop(record_index)
+        
+        # Sauvegarder
+        with open(DISSERTATIONS_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        
+        return jsonify({
+            "success": True,
+            "message": "Enregistrement supprimé avec succès"
+        })
+        
+    except Exception as e:
+        logging.error(f"Erreur lors de la suppression: {e}")
+        return jsonify({
+            "success": False,
+            "error": "Erreur lors de la suppression"
+        }), 500
+
+# --- API pour vider toutes les données ---
+@app.route('/api/gestion/dissertations/clear', methods=['DELETE'])
+def clear_all_dissertations():
+    """Vide toutes les données des dissertations."""
+    try:
+        # Créer un fichier vide
+        with open(DISSERTATIONS_FILE, 'w', encoding='utf-8') as f:
+            json.dump([], f)
+        
+        return jsonify({
+            "success": True,
+            "message": "Toutes les données ont été supprimées"
+        })
+        
+    except Exception as e:
+        logging.error(f"Erreur lors de la suppression générale: {e}")
+        return jsonify({
+            "success": False,
+            "error": "Erreur lors de la suppression"
+        }), 500
+
 # --- NOUVELLE Route API pour lister les cours ---
 @app.route('/api/philosophy/courses', methods=['GET'])
 def get_philosophy_courses():
@@ -90,11 +227,13 @@ def get_philosophy_courses():
         if conn:
             conn.close()
 
-# --- Route API pour la génération de dissertation (MODIFIÉE) ---
+# --- Route API pour la génération de dissertation (MODIFIÉE avec logging) ---
 @app.route('/api/generate_dissertation', methods=['POST'])
 def generate_dissertation_api():
     if not client:
-        return jsonify({"error": "Le service IA n'est pas correctement configuré."}), 503
+        error_msg = "Le service IA n'est pas correctement configuré."
+        save_dissertation_data(request.json or {}, None, False, error_msg)
+        return jsonify({"error": error_msg}), 503
 
     data = request.json
     sujet = data.get('question', '').strip()
@@ -102,17 +241,23 @@ def generate_dissertation_api():
     course_id = data.get('courseId') # Nouvel ID de cours optionnel
 
     if not sujet:
-        return jsonify({"error": "Le champ 'question' est obligatoire."}), 400
+        error_msg = "Le champ 'question' est obligatoire."
+        save_dissertation_data(data, None, False, error_msg)
+        return jsonify({"error": error_msg}), 400
         
     if dissertation_type not in ['type1', 'type2']:
-        return jsonify({"error": "Type de méthodologie invalide."}), 400
+        error_msg = "Type de méthodologie invalide."
+        save_dissertation_data(data, None, False, error_msg)
+        return jsonify({"error": error_msg}), 400
 
     # Récupérer le contenu du cours si un ID est fourni
     context_str = ""
     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
+            error_msg = "Connexion à la base de données échouée pour récupérer le contexte."
+            save_dissertation_data(data, None, False, error_msg)
+            return jsonify({"error": error_msg}), 503
         try:
             with conn.cursor(cursor_factory=RealDictCursor) as cur:
                 cur.execute("SELECT content FROM cours_philosophie WHERE id = %s", (course_id,))
@@ -131,8 +276,10 @@ def generate_dissertation_api():
         prompt_template = load_prompt(prompt_filename)
         
         if "Erreur:" in prompt_template:
-             logging.error(f"Fichier de prompt non trouvé : {prompt_filename}")
-             return jsonify({"error": "Configuration du prompt introuvable pour ce type."}), 500
+            error_msg = "Configuration du prompt introuvable pour ce type."
+            logging.error(f"Fichier de prompt non trouvé : {prompt_filename}")
+            save_dissertation_data(data, None, False, error_msg)
+            return jsonify({"error": error_msg}), 500
 
         # Injecter le sujet ET le contexte dans le prompt
         final_prompt = prompt_template.format(phi_prompt=sujet, context=context_str)
@@ -150,14 +297,21 @@ def generate_dissertation_api():
         )
 
         if response.parsed:
-            return jsonify(response.parsed.dict())
+            result = response.parsed.dict()
+            # Sauvegarder les données avec succès
+            save_dissertation_data(data, result, True)
+            return jsonify(result)
         else:
+            error_msg = "Le modèle n'a pas pu générer une structure valide."
             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
+            save_dissertation_data(data, None, False, error_msg)
+            return jsonify({"error": error_msg}), 500
 
     except Exception as e:
+        error_msg = f"Une erreur est survenue avec le service IA : {e}"
         logging.error(f"Erreur de génération Gemini : {e}")
-        return jsonify({"error": f"Une erreur est survenue avec le service IA : {e}"}), 500
+        save_dissertation_data(data, None, False, error_msg)
+        return jsonify({"error": error_msg}), 500
 
 if __name__ == '__main__':
     app.run(debug=True, port=5001)