Update app.py

app.py

@@ -1,486 +1,334 @@
-# app.py
-
-import json
-import os
-import sys
-import io 
-import uuid 
-from functools import wraps
-from datetime import datetime 
-from flask import Flask, request, jsonify, Response, session
-from flask_cors import CORS
-import baserow_storage # Assurez-vous que ceci est présent
-
-# Importation des modules backend
-from auth_backend import (
-    register_user, 
-    login_user, 
-    get_user_by_id,
-    get_plan_limit, 
-    reset_password_via_security_question, 
-    generate_password_hash,
-    # Nouvelles fonctions pour la gestion des utilisateurs finaux
-    register_end_user, 
-    login_end_user,    
-    reset_end_user_password_by_client 
-)
-from decorators import api_key_required # <-- NOUVEL IMPORT
-
-# Importation des Blueprints
-from web_routes import web_bp
-from user_routes import user_bp
-from billing_routes import billing_bp
-
-
-# Valeur par défaut pour la taille max de contenu
-DEFAULT_MAX_CONTENT_LENGTH = 16 * 1024 * 1024 
-
-
-# --- Initialisation de l'Application Flask ---
-app = Flask(__name__) 
-
-from werkzeug.middleware.proxy_fix import ProxyFix
-app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_port=1, x_prefix=1)
-# ------------------------------------------------------------------
-
-# Configuration
-app.secret_key = os.environ.get("FLASK_SECRET_KEY", "super_secret_dev_key") 
-app.config['MAX_CONTENT_LENGTH'] = DEFAULT_MAX_CONTENT_LENGTH 
-
-# Permettre les requêtes cross-origin (CORS)
-CORS(app, supports_credentials=True, origins="*", allow_headers=["Content-Type", "X-User-API-Key"])
-
-
-# Permettre les requêtes cross-origin pour l'API
-CORS(app) 
-
-# --- Enregistrement des Blueprints (Nouveau) ---
-app.register_blueprint(web_bp)
-app.register_blueprint(user_bp) 
-app.register_blueprint(billing_bp) # <-- NOUVEL ENREGISTREMENT
-
-
-# --- Décorateurs d'Authentification (Conservés) ---
-def login_required(f):
-    @wraps(f)
-    def decorated_function(*args, **kwargs):
-        if 'user_id' not in session:
-            # Redirection HTTP 302 vers la page de connexion pour les requêtes non-API
-            if not request.path.startswith('/api/'):
-                from flask import redirect, url_for
-                return redirect(url_for('user_bp.connexion')) 
-            # Réponse JSON pour les API
-            return jsonify({"status": "Error", "message": "Accès non autorisé. Veuillez vous connecter.", "code": "AUTH_REQUIRED"}), 401
-        return f(*args, **kwargs)
-    return decorated_function
-
-def user_api_key_required(f):
-    """Décorateur pour exiger la clé API dynamique via URL ('api_key') ou en-tête ('X-User-API-Key')."""
-    @wraps(f)
-    def decorated_function(*args, **kwargs):
-        api_key = request.args.get('api_key') or request.headers.get('X-User-API-Key')
-        
-        if not api_key:
-            return jsonify({
-                "status": "Error", 
-                "message": "Clé API utilisateur ('api_key' dans l'URL ou 'X-User-API-Key' dans l'en-tête) manquante.",
-                "code": "USER_API_KEY_MISSING"
-            }), 403
-        
-        user = get_user_by_api_key(api_key)
-        
-        if not user:
-            return jsonify({
-                "status": "Error", 
-                "message": "Clé API utilisateur invalide.",
-                "code": "USER_API_KEY_INVALID"
-            }), 403
-            
-        request.user_client_id = user['user_id']
-        request.user_client_data = user
-        
-        return f(*args, **kwargs)
-    return decorated_function
-
-
-# --- Routes d'Authentification (API - Conservées) ---
-
-@app.route("/api/register", methods=["POST"])
-def register():
-    data = request.get_json()
-    username = data.get("username")
-    email = data.get("email")
-    password = data.get("password")
-    confirm_password = data.get("confirm_password")
-    security_question = data.get("security_question")
-    security_answer = data.get("security_answer")
-
-    # CORRECTION ICI: Déballage des 3 valeurs retournées par register_user
-    user_id, message, new_user_data = register_user(username, email, password, confirm_password, security_question, security_answer)
-
-    if user_id and new_user_data: # Vérifier l'ID et les données pour s'assurer du succès
-        session['user_id'] = user_id
-        
-        # Réponse JSON pour l'API, incluant la clé API
-        return jsonify({
-            "message": message, 
-            "status": "Success", 
-            "user_id": user_id, 
-            # On récupère la clé API directement des données utilisateur
-            "api_key": new_user_data.get("api_key") 
-            }), 201
-    else:
-        # Échec de l'inscription (message d'erreur de register_user)
-        return jsonify({"message": message, "status": "Error"}), 400
-
-
-
-@app.route("/api/login", methods=["POST"])
-def login():
-    """
-    Route de connexion de l'utilisateur principal.
-    Prend le nom d'utilisateur/email et le mot de passe.
-    """
-    data = request.get_json()
-    username = data.get("username") 
-    password = data.get("password")
-
-    # CORRECTION DE L'ERREUR :
-    # Nous déballons maintenant 3 valeurs (ID, Message, Données Utilisateur)
-    # car la fonction login_user() dans auth_backend.py a été modifiée pour 
-    # retourner les 3 valeurs.
-    user_id, message, user_data = login_user(username, password)
-
-    # Note: user_data est la 3ème valeur (Dict des données utilisateur ou None)
-    if user_id and user_data: 
-        # La connexion est réussie
-        session['user_id'] = user_id
-        
-        # Réponse API avec la clé API de l'utilisateur pour les futures requêtes
-        return jsonify({
-            "message": message, 
-            "status": "Success", 
-            "user_id": user_id, 
-            # On utilise les données utilisateur (user_data) que nous avons déjà récupérées
-            "api_key": user_data.get("api_key") 
-        }), 200
-    else:
-        # La connexion a échoué (identifiants invalides ou autre erreur)
-        return jsonify({"message": message, "status": "Error"}), 401
-
-@app.route("/api/logout", methods=["POST"])
-def logout():
-    session.pop('user_id', None)
-    return jsonify({"message": "Déconnexion réussie.", "status": "Success"}), 200
-
-@app.route("/api/forgot-password", methods=["POST"])
-def forgot_password_api(): # Renommée pour éviter conflit avec la route HTML
-    data = request.get_json()
-    username_or_email = data.get("username_or_email")
-    security_answer = data.get("security_answer")
-    new_password = data.get("new_password")
-    
-    if not username_or_email or not security_answer or not new_password:
-        return jsonify({"message": "Champs manquants.", "status": "Error"}), 400
-        
-    success, message = reset_password_via_security_question(username_or_email, security_answer, new_password)
-    
-    if success:
-        return jsonify({
-            "message": message,
-            "status": "Success"
-        }), 200
-    else:
-        return jsonify({
-            "message": message,
-            "status": "Error"
-        }), 400
-
-
-# --- Routes de Gestion de Compte (API - Conservées) ---
-
-@app.route("/api/user/generate-key", methods=["POST"])
-@login_required
-def generate_user_api_key():
-    user_id = session.get('user_id')
-    
-    new_api_key = create_dynamic_api_key()
-    
-    success, message = update_user_data(user_id, {"api_key": new_api_key})
-    
-    if success:
-        return jsonify({
-            "message": "Clé API utilisateur générée et sauvegardée. Conservez-la en lieu sûr. **Utilisez-la via URL simple ('api_key=...') ou en-tête 'X-User-API-Key'.**",
-            "status": "Success",
-            "api_key": new_api_key
-        }), 200
-    else:
-        return jsonify({
-            "message": f"Erreur lors de la génération de la clé : {message}",
-            "status": "Error"
-        }), 500
-
-@app.route("/api/user/update-info", methods=["POST"])
-@login_required
-def update_user_info():
-    user_id = session.get('user_id')
-    data = request.get_json()
-    
-    updates = {}
-    if 'username' in data: 
-        updates['username'] = data['username']
-    if 'email' in data:
-        updates['email'] = data['email']
-    if 'plan' in data:
-        updates['plan'] = data['plan']
-        
-    if not updates:
-        return jsonify({
-            "message": "Aucune information à mettre à jour fournie.",
-            "status": "Error"
-        }), 400
-        
-    success, message = update_user_data(user_id, updates)
-
-    if success:
-        return jsonify({
-            "message": message,
-            "status": "Success"
-        }), 200
-    else:
-        return jsonify({
-            "message": f"Échec de la mise à jour : {message}",
-            "status": "Error"
-        }), 400
-
-
-# --- Nouvelle Route pour les Clients (API - Conservée) ---
-
-@app.route("/api/user-register", methods=["POST"])
-@user_api_key_required
-def user_register_via_api_key():
-    client_user_id = request.user_client_id
-    client_data = request.user_client_data
-    
-    data = request.get_json()
-    username = data.get("username")
-    email = data.get("email")
-    password = data.get("password")
-    
-    current_count = client_data.get("created_accounts_count", 0)
-    plan_limit = get_plan_limit(client_data.get("plan", "free"))
-    
-    if current_count >= plan_limit:
-        
-        if client_data.get("plan", "free") == "free" and plan_limit == 500:
-             return jsonify({
-                "message": "Erreur: Le plan gratuit ne peut pas prendre plus de 500 comptes utilisateur.",
-                "status": "Error",
-                "code": "PLAN_LIMIT_EXCEEDED"
-            }), 402
-        
-        return jsonify({
-            "message": f"Erreur: Votre plan actuel ({client_data.get('plan').upper()}) limite la création de comptes à {plan_limit}. Veuillez passer à un plan supérieur.",
-            "status": "Error",
-            "code": "PLAN_LIMIT_EXCEEDED"
-        }), 402
-    
-    if not username or not email or len(password) < 8:
-         return jsonify({"message": "Nom d'utilisateur, email ou mot de passe invalide (min 8 caractères).", "status": "Error"}), 400
-         
-    users = load_users_data()
-    if any(u.get("email") == email for u in users.values()) or any(u.get("username") == username for u in users.values()):
-        return jsonify({"message": "Cet email ou nom d'utilisateur est déjà enregistré.", "status": "Error"}), 400
-
-    end_user_id = str(uuid.uuid4())
-    hashed_password = generate_password_hash(password)
-
-    new_end_user = {
-        "username": username,
-        "email": email,
-        "password_hash": hashed_password,
-        "user_id": end_user_id,
-        "created_at": datetime.now().isoformat(),
-        "api_key": None,
-        "plan": "end_user",
-        "created_accounts_count": 0,
-        "security_question": None,
-        "security_answer": None
-    }
-    users[end_user_id] = new_end_user
-    
-    new_count = current_count + 1
-    client_data["created_accounts_count"] = new_count
-    users[client_user_id] = client_data
-    
-    commit_msg = f"feat: End-user registration via API Key. Client: {client_data.get('username')}. New count: {new_count}"
-    success_save = save_users_data(users, commit_message=commit_msg)
-
-    if not success_save:
-        return jsonify({"message": "Erreur critique lors de la sauvegarde (Git).", "status": "Error"}), 500
-
-    return jsonify({
-        "message": "Inscription de l'utilisateur final réussie.", 
-        "status": "Success", 
-        "user_id": end_user_id, 
-        "accounts_remaining": plan_limit - new_count
-    }), 201
-
-
-# ----------------------------------------------------------------------
-# --- NOUVELLES ROUTES API POUR LA GESTION DES UTILISATEURS FINAUX ---
-# ----------------------------------------------------------------------
-
-@app.route("/api/enduser/register", methods=["POST"])
-@api_key_required
-def api_enduser_register(client_user):
-    """
-    Route API pour l'inscription d'un utilisateur final par un client (via sa clé API).
-    Le 'client_user' est injecté par le décorateur api_key_required.
-    """
-    data = request.get_json()
-    username = data.get("username")
-    email = data.get("email")
-    password = data.get("password")
-    
-    client_user_id = client_user['user_id']
-    
-    end_user_id, success, message = register_end_user(
-        client_user_id, 
-        username, 
-        email, 
-        password
-    )
-    
-    if success:
-        return jsonify({
-            "message": message, 
-            "status": "Success", 
-            "end_user_id": end_user_id,
-        }), 201
-    else:
-        return jsonify({"message": message, "status": "Error"}), 400
-
-@app.route("/api/enduser/login", methods=["POST"])
-@api_key_required
-def api_enduser_login(client_user):
-    """
-    Route API pour la connexion d'un utilisateur final par un client (via sa clé API).
-    Le 'client_user' est injecté par le décorateur api_key_required.
-    """
-    data = request.get_json()
-    username_or_email = data.get("username_or_email") # Accepte username ou email
-    password = data.get("password")
-    
-    client_user_id = client_user['user_id']
-    
-    if not all([username_or_email, password]):
-        return jsonify({"message": "L'identifiant de l'utilisateur final et le mot de passe sont requis.", "status": "Error"}), 400
-
-    # CORRECTION : La fonction retourne (end_user_id, message, user_info)
-    end_user_id, message, user_info = login_end_user(
-        client_user_id, 
-        username_or_email, 
-        password
-    )
-
-    if end_user_id and user_info: # Si l'ID est présent (succès)
-        return jsonify({
-            "message": message, 
-            "status": "Success", 
-            "user": user_info
-        }), 200
-    else:
-        return jsonify({"message": message, "status": "Error"}), 401
-
-@app.route("/api/enduser/recover-password", methods=["POST"])
-@api_key_required
-def api_enduser_recover_password(client_user):
-    """
-    Route API pour la récupération/réinitialisation du mot de passe d'un utilisateur final
-    par le client (via sa clé API).
-    Le 'client_user' est injecté par le décorateur api_key_required.
-    """
-    data = request.get_json()
-    end_user_identifier = data.get("username_or_email") # Identifiant de l'utilisateur final à réinitialiser
-    new_password = data.get("new_password")
-    
-    client_user_id = client_user['user_id']
-    
-    if not all([end_user_identifier, new_password]):
-        return jsonify({"message": "L'identifiant de l'utilisateur final et le nouveau mot de passe sont requis.", "status": "Error"}), 400
-        
-    success, message = reset_end_user_password_by_client(
-        client_user_id,
-        end_user_identifier,
-        new_password
-    )
-    
-    if success:
-        return jsonify({"message": message, "status": "Success"}), 200
-    else:
-        return jsonify({"message": message, "status": "Error"}), 400
-
-# app.py
-
-
-@app.route("/api/user-info", methods=["GET"])
-@api_key_required
-def api_user_info(client_user):
-    """
-    Route API pour récupérer les informations de l'utilisateur principal (client)
-    à partir de la clé API fournie.
-    Le 'client_user' est injecté par le décorateur api_key_required.
-    """
-    # client_user est l'objet utilisateur complet injecté par le décorateur
-    
-    # Sécurité : créer une copie et supprimer les données sensibles avant l'envoi
-    user_info_safe = client_user.copy()
-    user_info_safe.pop('password_hash', None)
-    user_info_safe.pop('security_answer_hash', None)
-    
-    return jsonify({
-        "message": "Informations utilisateur récupérées avec succès.",
-        "status": "Success", 
-        "user": user_info_safe
-    }), 200
-
-
-
-@app.route("/api/health", methods=["GET"])
-def health_check():
-    """Vérifie l'état du service en utilisant le statut Baserow."""
-    
-    # 1. Tenter d'obtenir le statut Baserow réel
-    try:
-        # Appelle la fonction de baserow_storage pour vérifier l'état
-        health_status = baserow_storage.get_health_status()
-        
-        # Le statut 'data_storage' est la clé pour le frontend
-        db_status_message = health_status.get('data_storage', 'Unknown')
-        
-        # Si la DB est 'operational', on envoie 'Ready'
-        if db_status_message == 'operational':
-             data_status = "Ready"
-        else:
-             data_status = f"Failed (Baserow: {db_status_message})"
-             
-    except Exception as e:
-        # Erreur générale, Baserow inaccessible ou problème de configuration critique
-        data_status = f"Failed (Exception: {str(e)})"
-        
-    return jsonify({
-        "status": "Online",
-        "data_storage": data_status
-    }), 200
-
-@app.route("/", methods=["GET"])
-def read_root():
-    """Endpoint racine pour le Health Check (Flask version)."""
-    
-    if baserow_storage.is_baserow_up():
-        # Statut OK (200) avec le message
-        return jsonify({"status": "ok", "message": "Backend and Baserow API are reachable."}), 200
-    else:
-        # Statut de service non disponible (503) avec le message d'erreur
-        return jsonify({"detail": "Baserow service unavailable (Health Check failed)."}), 503
+# app.py
+import requests
+import json
+import os
+import sys
+import io 
+import uuid 
+from functools import wraps
+from datetime import datetime 
+from flask import Flask, request, jsonify, Response, session
+from flask_cors import CORS
+import baserow_storage # Assurez-vous que ceci est présent
+
+# Importation des modules backend
+from auth_backend import ( 
+    get_user_by_id,
+    get_plan_limit, 
+    reset_password_via_security_question, 
+    generate_password_hash,
+)
+from decorators import api_key_required # <-- NOUVEL IMPORT
+
+# Importation des Blueprints
+from web_routes import web_bp
+from user_routes import user_bp
+from billing_routes import billing_bp
+
+
+# Valeur par défaut pour la taille max de contenu
+DEFAULT_MAX_CONTENT_LENGTH = 16 * 1024 * 1024 
+
+
+# --- Initialisation de l'Application Flask ---
+app = Flask(__name__) 
+
+from werkzeug.middleware.proxy_fix import ProxyFix
+app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_port=1, x_prefix=1)
+# ------------------------------------------------------------------
+
+# Configuration
+app.secret_key = os.environ.get("FLASK_SECRET_KEY", "super_secret_dev_key") 
+app.config['MAX_CONTENT_LENGTH'] = DEFAULT_MAX_CONTENT_LENGTH 
+
+# Permettre les requêtes cross-origin (CORS)
+CORS(app, supports_credentials=True, origins="*", allow_headers=["Content-Type", "X-User-API-Key"])
+
+
+# Permettre les requêtes cross-origin pour l'API
+CORS(app) 
+
+# --- Enregistrement des Blueprints (Nouveau) ---
+app.register_blueprint(web_bp)
+app.register_blueprint(user_bp) 
+app.register_blueprint(billing_bp) # <-- NOUVEL ENREGISTREMENT
+
+
+# --- Décorateurs d'Authentification (Conservés) ---
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'user_id' not in session:
+            # Redirection HTTP 302 vers la page de connexion pour les requêtes non-API
+            if not request.path.startswith('/api/'):
+                from flask import redirect, url_for
+                return redirect(url_for('user_bp.connexion')) 
+            # Réponse JSON pour les API
+            return jsonify({"status": "Error", "message": "Accès non autorisé. Veuillez vous connecter.", "code": "AUTH_REQUIRED"}), 401
+        return f(*args, **kwargs)
+    return decorated_function
+
+
+# --- Routes d'Authentification (API - Conservées) ---
+
+@app.route("/api/register", methods=["POST"])
+def register():
+    data = request.get_json()
+    username = data.get("username")
+    email = data.get("email")
+    password = data.get("password")
+    confirm_password = data.get("confirm_password")
+    security_question = data.get("security_question")
+    security_answer = data.get("security_answer")
+
+    # CORRECTION ICI: Déballage des 3 valeurs retournées par register_user
+    user_id, message, new_user_data = register_user(username, email, password, confirm_password, security_question, security_answer)
+
+    if user_id and new_user_data: # Vérifier l'ID et les données pour s'assurer du succès
+        session['user_id'] = user_id
+        
+        # Réponse JSON pour l'API, incluant la clé API
+        return jsonify({
+            "message": message, 
+            "status": "Success", 
+            "user_id": user_id, 
+            # On récupère la clé API directement des données utilisateur
+            "api_key": new_user_data.get("api_key") 
+            }), 201
+    else:
+        # Échec de l'inscription (message d'erreur de register_user)
+        return jsonify({"message": message, "status": "Error"}), 400
+
+
+
+@app.route("/api/login", methods=["POST"])
+def login():
+    """
+    Route de connexion de l'utilisateur principal.
+    Prend le nom d'utilisateur/email et le mot de passe.
+    """
+    data = request.get_json()
+    username = data.get("username") 
+    password = data.get("password")
+
+    # CORRECTION DE L'ERREUR :
+    # Nous déballons maintenant 3 valeurs (ID, Message, Données Utilisateur)
+    # car la fonction login_user() dans auth_backend.py a été modifiée pour 
+    # retourner les 3 valeurs.
+    user_id, message, user_data = login_user(username, password)
+
+    # Note: user_data est la 3ème valeur (Dict des données utilisateur ou None)
+    if user_id and user_data: 
+        # La connexion est réussie
+        session['user_id'] = user_id
+        
+        # Réponse API avec la clé API de l'utilisateur pour les futures requêtes
+        return jsonify({
+            "message": message, 
+            "status": "Success", 
+            "user_id": user_id, 
+            # On utilise les données utilisateur (user_data) que nous avons déjà récupérées
+            "api_key": user_data.get("api_key") 
+        }), 200
+    else:
+        # La connexion a échoué (identifiants invalides ou autre erreur)
+        return jsonify({"message": message, "status": "Error"}), 401
+
+@app.route("/api/logout", methods=["POST"])
+def logout():
+    session.pop('user_id', None)
+    return jsonify({"message": "Déconnexion réussie.", "status": "Success"}), 200
+
+@app.route("/api/forgot-password", methods=["POST"])
+def forgot_password_api(): # Renommée pour éviter conflit avec la route HTML
+    data = request.get_json()
+    username_or_email = data.get("username_or_email")
+    security_answer = data.get("security_answer")
+    new_password = data.get("new_password")
+    
+    if not username_or_email or not security_answer or not new_password:
+        return jsonify({"message": "Champs manquants.", "status": "Error"}), 400
+        
+    success, message = reset_password_via_security_question(username_or_email, security_answer, new_password)
+    
+    if success:
+        return jsonify({
+            "message": message,
+            "status": "Success"
+        }), 200
+    else:
+        return jsonify({
+            "message": message,
+            "status": "Error"
+        }), 400
+
+
+# --- Routes de Gestion de Compte (API - Conservées) ---
+
+@app.route("/api/user/generate-key", methods=["POST"])
+@login_required
+def generate_user_api_key():
+    user_id = session.get('user_id')
+    
+    new_api_key = create_dynamic_api_key()
+    
+    success, message = update_user_data(user_id, {"api_key": new_api_key})
+    
+    if success:
+        return jsonify({
+            "message": "Clé API utilisateur générée et sauvegardée. Conservez-la en lieu sûr. **Utilisez-la via URL simple ('api_key=...') ou en-tête 'X-User-API-Key'.**",
+            "status": "Success",
+            "api_key": new_api_key
+        }), 200
+    else:
+        return jsonify({
+            "message": f"Erreur lors de la génération de la clé : {message}",
+            "status": "Error"
+        }), 500
+
+@app.route("/api/user/update-info", methods=["POST"])
+@login_required
+def update_user_info():
+    user_id = session.get('user_id')
+    data = request.get_json()
+    
+    updates = {}
+    if 'username' in data: 
+        updates['username'] = data['username']
+    if 'email' in data:
+        updates['email'] = data['email']
+    if 'plan' in data:
+        updates['plan'] = data['plan']
+        
+    if not updates:
+        return jsonify({
+            "message": "Aucune information à mettre à jour fournie.",
+            "status": "Error"
+        }), 400
+        
+    success, message = update_user_data(user_id, updates)
+
+    if success:
+        return jsonify({
+            "message": message,
+            "status": "Success"
+        }), 200
+    else:
+        return jsonify({
+            "message": f"Échec de la mise à jour : {message}",
+            "status": "Error"
+        }), 400
+
+
+
+@app.route("/api/user-info", methods=["GET"])
+@api_key_required
+def api_user_info(client_user):
+    """
+    Route API pour récupérer les informations de l'utilisateur principal (client)
+    à partir de la clé API fournie.
+    Le 'client_user' est injecté par le décorateur api_key_required.
+    """
+    # client_user est l'objet utilisateur complet injecté par le décorateur
+    
+    # Sécurité : créer une copie et supprimer les données sensibles avant l'envoi
+    user_info_safe = client_user.copy()
+    user_info_safe.pop('password_hash', None)
+    user_info_safe.pop('security_answer_hash', None)
+    
+    return jsonify({
+        "message": "Informations utilisateur récupérées avec succès.",
+        "status": "Success", 
+        "user": user_info_safe
+    }), 200
+
+
+
+@app.route("/api/health", methods=["GET"])
+def health_check():
+    """Vérifie l'état du service en utilisant le statut Baserow."""
+    
+    # 1. Tenter d'obtenir le statut Baserow réel
+    try:
+        # Appelle la fonction de baserow_storage pour vérifier l'état
+        health_status = baserow_storage.get_health_status()
+        
+        # Le statut 'data_storage' est la clé pour le frontend
+        db_status_message = health_status.get('data_storage', 'Unknown')
+        
+        # Si la DB est 'operational', on envoie 'Ready'
+        if db_status_message == 'operational':
+             data_status = "Ready"
+        else:
+             data_status = f"Failed (Baserow: {db_status_message})"
+             
+    except Exception as e:
+        # Erreur générale, Baserow inaccessible ou problème de configuration critique
+        data_status = f"Failed (Exception: {str(e)})"
+        
+    return jsonify({
+        "status": "Online",
+        "data_storage": data_status
+    }), 200
+
+@app.route("/", methods=["GET"])
+def read_root():
+    """Endpoint racine pour le Health Check (Flask version)."""
+    
+    if baserow_storage.is_baserow_up():
+        # Statut OK (200) avec le message
+        return jsonify({"status": "ok", "message": "Backend and Baserow API are reachable."}), 200
+    else:
+        # Statut de service non disponible (503) avec le message d'erreur
+        return jsonify({"detail": "Baserow service unavailable (Health Check failed)."}), 503
+
+# ----------------------------------------------------------------------
+# --- Nouvelle Fonctionnalité : Validation d'Email en Temps Réel ---
+# ----------------------------------------------------------------------
+
+@app.route("/api/validate-email", methods=["GET"])
+@api_key_required
+def validate_email_realtime(client_user):
+    """
+    Endpoint API pour la validation d'email en temps réel.
+    L'authentification se fait via la clé API (dans 'api_key' ou 'X-API-Key').
+    L'email est lu depuis le paramètre d'URL 'email'.
+    """
+    email_to_validate = request.args.get('email')
+    
+    # 1. Vérification de la présence de l'email
+    if not email_to_validate:
+        return jsonify({
+            "status": "Error", 
+            "message": "Le paramètre 'email' est manquant dans l'URL.",
+            "code": "EMAIL_PARAM_MISSING"
+        }), 400
+
+    # 2. Validation d'appel au service externe (À REMPLACER par votre code réel)
+    
+    # Placeholder pour un service de vérification d'email en temps réel
+    # Assurez-vous d'implémenter ici la logique d'appel à l'API de validation
+    # (ex: ZeroBounce, MailboxValidator, etc.) en utilisant la librairie 'requests'.
+    
+    is_valid = False
+    message = "Vérification indisponible : Remplacez ce code par l'appel à votre service de validation d'email."
+    
+    # --- DÉBUT DU PLACEHOLDER SIMPLE ---
+    import re
+    if re.match(r"[^@]+@[^@]+\.[^@]+", email_to_validate):
+        is_valid = True
+        message = "Le format de l'email est valide (Validation de base). Intégrez ici votre API de validation en temps réel."
+    else:
+        is_valid = False
+        message = "Format de l'email invalide."
+    # --- FIN DU PLACEHOLDER SIMPLE ---
+
+    # 3. Réponse API
+    return jsonify({
+        "status": "Success" if is_valid else "Error", 
+        "message": message,
+        "email": email_to_validate,
+        "is_valid": is_valid,
+        # Optionnel: l'ID de l'utilisateur qui fait la requête
+        "client_user_id": client_user.get('user_id') 
+    }), 200 if is_valid else 400