Update web_routes.py

web_routes.py

@@ -6,8 +6,8 @@ from werkzeug.utils import secure_filename # <-- NOUVEL IMPORT (pourrait ne pas
 import os 
 import uuid # <-- NOUVEL IMPORT
 from auth_backend import get_plan_details 
-from baserow_storage import get_health_status
-
+from baserow_storage import get_health_status, update_user_deployment_data, get_deployment_by_id 
+import huggingface_storage
 # NOUVEAU : Fonction pour vérifier les extensions autorisées pour le déploiement statique
 def allowed_static_file(filename):
     """Vérifie si le fichier a une extension autorisée (HTML, CSS, JS)."""
@@ -105,7 +105,6 @@ def html_launcher():
     return render_template("html_launcher.html") 
 
 
-# --- NOUVELLE ROUTE : Page de Déploiement Statique ---
 @web_bp.route("/static-deploy")
 def static_deploy_page():
     """
@@ -116,7 +115,8 @@ def static_deploy_page():
     
     # Si un ID existe, on peut récupérer la liste des fichiers pour l'afficher
     files = []
-    base_dir = None
+    launch_url_for_display = None # Initialisation de la variable pour l'URL partageable
+    
     if deploy_id:
         base_dir = os.path.join(current_app.config['UPLOAD_FOLDER'], deploy_id)
         if os.path.exists(base_dir):
@@ -129,11 +129,17 @@ def static_deploy_page():
     
     # L'état du bouton "Lancer"
     index_file_present = 'index.html' in files
+
+    # --- NOUVEAU : Générer l'URL partageable si un déploiement est actif ---
+    if deploy_id and index_file_present:
+        # Générer l'URL complète. _external=True crée un lien absolu (https://...)
+        launch_url_for_display = url_for('web_bp.serve_static', deploy_id=deploy_id, filename='index.html', _external=True)
     
     return render_template("static_deploy.html", 
                            files=files, 
                            index_file_present=index_file_present,
-                           deploy_id=deploy_id)
+                           deploy_id=deploy_id,
+                           launch_url=launch_url_for_display) # <-- Passage de l'URL au template
 
 # --- NOUVELLE ROUTE : Upload de Fichiers Statiques Multiples ---
 @web_bp.route("/upload-static", methods=['POST'])
@@ -204,32 +210,274 @@ def upload_static_files():
         "deploy_id": deploy_id
     }), 200
 
-# --- NOUVELLE ROUTE : Servir les Fichiers Statiques ---
+@web_bp.route("/upload-files", methods=['POST'])
+# @login_required # Vous devez vous assurer que l'utilisateur est connecté et session['user_id'] est disponible
+def upload_files():
+    """
+    Gère le téléversement des fichiers utilisateur, les enregistre dans un dossier
+    temporaire, puis les téléverse en un seul commit sur le Dataset Hugging Face.
+    """
+    if 'user_id' not in session:
+        return jsonify({
+            "status": "error", 
+            "message": "Authentification requise pour téléverser."
+        }), 401
+
+    if not request.files:
+        return jsonify({
+            "status": "error", 
+            "message": "Aucun fichier n'a été reçu."
+        }), 400
+
+    user_id = session['user_id']
+    # Générer un ID unique qui sera le nom du dossier sur Hugging Face et l'ID dans Baserow
+    deploy_id = str(uuid.uuid4()) 
+    
+    # 1. Créer le dossier temporaire local pour la collecte des fichiers
+    # Le dossier temporaire est nécessaire pour utiliser upload_folder() de huggingface_hub
+    upload_dir = os.path.join(current_app.config['UPLOAD_FOLDER'], deploy_id)
+    os.makedirs(upload_dir, exist_ok=True)
+    
+    uploaded_files_list = []
+    index_html_present = False
+    
+    try:
+        # 2. Enregistrer tous les fichiers dans le dossier temporaire local
+        for file_key in request.files:
+            file = request.files[file_key]
+            if file and allowed_static_file(file.filename):
+                filename = secure_filename(file.filename)
+                file_path = os.path.join(upload_dir, filename)
+                file.save(file_path)
+                uploaded_files_list.append(filename)
+                
+                if filename.lower() == 'index.html':
+                    index_html_present = True
+        
+        # Vérification si des fichiers ont été réellement enregistrés
+        if not uploaded_files_list:
+            shutil.rmtree(upload_dir) # Nettoyer le dossier vide
+            return jsonify({
+                "status": "error", 
+                "message": "Aucun fichier valide n'a été téléversé."
+            }), 400
+
+        # --- LOGIQUE PERSISTANTE HUGGING FACE ---
+        
+        # 3. Téléverser le dossier complet vers Hugging Face (1 seule commit)
+        success_hf, message_hf, full_repo_path = huggingface_storage.upload_project_folder_to_hf(
+            local_folder_path=upload_dir,
+            deploy_id=deploy_id
+        )
+        
+        if not success_hf:
+            # Échec du téléversement HF. On nettoie le dossier temporaire local.
+            shutil.rmtree(upload_dir) 
+            return jsonify({
+                "status": "error", 
+                "message": f"Échec de la persistance des fichiers sur Hugging Face: {message_hf}"
+            }), 500
+        
+        # 4. Enregistrer l'ID de déploiement dans Baserow
+        success_db, message_db, baserow_row_id = save_new_deployment(
+            user_id=user_id, 
+            deploy_id=deploy_id, 
+            index_file_present=index_html_present,
+            full_repo_path=full_repo_path
+        )
+        
+        # 5. Nettoyage et vérification finale
+        shutil.rmtree(upload_dir) # Suppression du dossier temporaire local
+        
+        if not success_db:
+             # Si Baserow échoue, on annule en supprimant le projet HF (pour éviter les orphelins)
+             current_app.logger.warning(f"Annulation du déploiement {deploy_id} suite à l'échec Baserow.")
+             huggingface_storage.delete_project_folder_from_hf(deploy_id)
+             return jsonify({
+                "status": "error", 
+                "message": f"Fichiers téléversés mais échec d'enregistrement dans Baserow. Annulation: {message_db}"
+            }), 500
+            
+        # 6. Succès
+        launch_url = url_for('web_bp.serve_static', deploy_id=deploy_id, filename='index.html', _external=True)
+        
+        return jsonify({
+            "status": "success", 
+            "message": "Fichiers téléversés et persistés avec succès sur Hugging Face.",
+            "file_count": len(uploaded_files_list),
+            "index_present": index_html_present,
+            "launch_url": launch_url,
+            "deploy_id": deploy_id
+        }), 200
+
+    except Exception as e:
+        # Tenter de nettoyer le dossier local en cas d'erreur inattendue
+        if os.path.isdir(upload_dir):
+            shutil.rmtree(upload_dir)
+        current_app.logger.error(f"Erreur lors du traitement du téléversement: {e}")
+        return jsonify({
+            "status": "error", 
+            "message": f"Une erreur inattendue est survenue: {str(e)}"
+        }), 500
+
+
+# --- ROUTE MODIFIÉE : Servir les Fichiers Persistants ---
 @web_bp.route("/serve-static/<deploy_id>/<path:filename>")
 def serve_static(deploy_id, filename):
     """
-    Sert les fichiers statiques (HTML, CSS, JS, images) à partir du dossier
-    temporaire identifié par deploy_id.
+    Sert les fichiers statiques (HTML, CSS, JS, images).
+    Télécharge le dossier du projet depuis Hugging Face si il n'est pas déjà en cache local.
     """
-    # 1. Sécurité: Rejeter toute tentative de traversée de répertoire (..)
+    # 1. Sécurité
     if '..' in filename:
         return "Accès refusé: Tentative de traversée de répertoire", 403
         
-    # 2. Définir le répertoire de base de l'ID de déploiement
+    # 2. Définir le répertoire de base de l'ID de déploiement local (cache)
     root_dir = os.path.join(current_app.config['UPLOAD_FOLDER'], deploy_id)
+    file_path = os.path.join(root_dir, filename)
 
-    # 3. Vérifier que le fichier est bien autorisé (pour la sécurité, même si on utilise send_from_directory)
+    # 3. Vérifier la présence du fichier en cache local. Si absent, tenter le téléchargement.
+    if not os.path.exists(file_path):
+        
+        # Vérifier l'ID dans Baserow avant de tenter le téléchargement (vérifie la validité)
+        deployment_data = get_deployment_by_id(deploy_id)
+        if deployment_data is None:
+            return "Projet non trouvé (ID invalide)", 404
+            
+        # Tenter de télécharger le dossier complet depuis Hugging Face
+        success, message = huggingface_storage.get_project_files_from_hf(
+            deploy_id=deploy_id, 
+            local_target_path=root_dir
+        )
+        
+        if not success:
+            current_app.logger.error(f"Échec du téléchargement HF pour {deploy_id}: {message}")
+            return "Fichiers du projet indisponibles", 503
+            
+    # 4. Sécurité du type de fichier
     if not allowed_static_file(filename):
         return "Type de fichier non autorisé", 403
         
-    # 4. Utiliser send_from_directory pour servir le fichier
+    # 5. Servir le fichier depuis le cache local
+    try:
+        return send_from_directory(root_dir, filename)
+    except FileNotFoundError:
+        return "Fichier non trouvé dans le projet", 404
+    except Exception as e:
+        current_app.logger.error(f"Erreur lors du service du fichier {filename} pour {deploy_id}: {e}")
+        return "Erreur interne du serveur", 500
+
+@web_bp.route("/deploy/static", methods=["POST"])
+def deploy_static_file():
+    """
+    Gère le téléversement de fichiers statiques, les persiste sur Hugging Face,
+    et enregistre les métadonnées de déploiement sur la ligne de l'utilisateur
+    dans la table PRIMARY_USERS_TABLE_ID de Baserow.
+    """
+    
+    # 1. Vérification de la session utilisateur et de l'authentification
+    user_data = session.get('user_data')
+    if not user_data:
+        current_app.logger.error("Tentative de déploiement sans session utilisateur.")
+        return jsonify({"success": False, "message": "Session utilisateur introuvable. Veuillez vous reconnecter."}), 401
+    
+    # Récupérer l'ID de ligne Baserow de l'utilisateur et l'ID interne
+    user_baserow_row_id = user_data.get('baserow_row_id')
+    user_id = user_data.get('id') # L'ID interne de l'utilisateur (utilisé comme User Link)
+    
+    if not user_baserow_row_id or not user_id:
+        current_app.logger.error(f"ID de base de données (Row ID: {user_baserow_row_id}) ou ID interne (ID: {user_id}) manquant.")
+        return jsonify({"success": False, "message": "Erreur critique: Données utilisateur incomplètes."}), 500
+
+    # 2. Vérification de la présence de fichiers
+    if not request.files:
+        return jsonify({"success": False, "message": "Aucun fichier n'a été reçu."}), 400
+
+    # 3. Préparation du déploiement
+    # Générer un ID unique qui sera le nom du dossier sur Hugging Face et l'ID de déploiement
+    deploy_id = str(uuid.uuid4()) 
+    
+    # Créer le dossier temporaire local pour la collecte des fichiers
+    upload_dir = os.path.join(current_app.config['UPLOAD_FOLDER'], deploy_id)
+    os.makedirs(upload_dir, exist_ok=True)
+    
+    uploaded_files_list = []
+    index_html_present = False
+    
     try:
-        # send_from_directory va gérer les mimetypes
-        return send_from_directory(
-            root_dir, 
-            filename,
-            conditional=True # Support des requêtes conditionnelles (mise en cache)
+        # 4. Enregistrement des fichiers dans le dossier temporaire local
+        for file_key in request.files:
+            file = request.files[file_key]
+            if file and allowed_static_file(file.filename):
+                filename = secure_filename(file.filename)
+                file_path = os.path.join(upload_dir, filename)
+                file.save(file_path)
+                uploaded_files_list.append(filename)
+                
+                if filename.lower() == 'index.html':
+                    index_html_present = True
+        
+        # Vérification si des fichiers ont été réellement enregistrés
+        if not uploaded_files_list:
+            shutil.rmtree(upload_dir) # Nettoyer le dossier vide
+            return jsonify({"success": False, "message": "Aucun fichier valide n'a été téléversé."}), 400
+
+        # --- LOGIQUE PERSISTANTE HUGGING FACE ---
+        
+        # 5. Téléverser le dossier complet vers Hugging Face (1 seule commit)
+        success_hf, message_hf, full_repo_path = huggingface_storage.upload_project_folder_to_hf(
+            local_folder_path=upload_dir,
+            deploy_id=deploy_id
+        )
+        
+        if not success_hf:
+            # Échec du téléversement HF. On nettoie le dossier temporaire local.
+            shutil.rmtree(upload_dir) 
+            return jsonify({
+                "success": False, 
+                "message": f"Échec de la persistance des fichiers sur Hugging Face: {message_hf}"
+            }), 500
+            
+        # 6. Mise à jour des données de déploiement sur la ligne de l'utilisateur Baserow
+        hf_repo_path = huggingface_storage.HF_DATASET_REPO_ID 
+        
+        # Le User Link (FIELD_USER_REF) est ici défini comme l'ID interne de l'utilisateur (user_id)
+        success_db, message_db = update_user_deployment_data(
+            user_baserow_row_id=user_baserow_row_id,
+            deploy_id=deploy_id, 
+            user_link=user_id, 
+            hf_repo_path=hf_repo_path
         )
-    except Exception:
-        # Fichier non trouvé ou autre erreur
-        return "Fichier non trouvé", 404
+        
+        # 7. Nettoyage et vérification finale
+        shutil.rmtree(upload_dir) # Suppression du dossier temporaire local
+        
+        if not success_db:
+            # Si l'enregistrement Baserow échoue, on annule tout (suppression du dossier HF)
+            huggingface_storage.delete_project_folder_from_hf(deploy_id)
+            current_app.logger.error(f"Échec de l'enregistrement Baserow pour {deploy_id} (User ID: {user_id}): {message_db}")
+            return jsonify({"success": False, "message": f"Erreur critique lors de l'enregistrement du projet: {message_db}. Annulation du déploiement."}), 500
+
+        # 8. Réponse réussie
+        # Si un index.html est présent, on utilise serve_static_file_default
+        route_to_serve = 'web_bp.serve_static_file_default' if index_html_present else 'web_bp.serve_static'
+        
+        deployment_url = url_for(route_to_serve, deploy_id=deploy_id, filename='index.html', _external=True) 
+
+        return jsonify({
+            "success": True, 
+            "message": "Déploiement statique réussi !", 
+            "deploy_id": deploy_id,
+            "url": deployment_url,
+            "index_present": index_html_present
+        }), 200
+        
+    except Exception as e:
+        # Tenter de nettoyer le dossier local en cas d'erreur inattendue
+        if os.path.isdir(upload_dir):
+            shutil.rmtree(upload_dir)
+        current_app.logger.error(f"Erreur lors du traitement du d��ploiement: {e}")
+        return jsonify({
+            "success": False, 
+            "message": f"Une erreur inattendue est survenue: {str(e)}"
+        }), 500