Upload 10 files

Dockerfile

@@ -0,0 +1,57 @@
+# ÉTAPE 1: Image de base
+FROM python:3.11-slim
+
+# ÉTAPE 2: Configuration et Dossier de travail
+# Ligne supprimée (ENV PORT 8080) pour laisser Hugging Face Spaces injecter le port correct ($PORT, généralement 7860).
+ENV FLASK_APP app.py
+ENV GUNICORN_WORKERS 4
+ENV GUNICORN_THREADS 2
+
+# Création et utilisation du répertoire /app
+WORKDIR /app
+
+# ÉTAPE 3: Installation des dépendances (OPTIMISATION CACHING)
+# Copie uniquement de requirements.txt pour mettre en cache l'installation
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt \
+    && rm requirements.txt
+
+# ÉTAPE 4: Copie de l'Application et des Fichiers
+# Nous copions tous les fichiers de l'application et nous assurons que
+# l'utilisateur 'user' en est le propriétaire.
+
+# CORRECTION MAJEURE : Ajout du dossier templates
+# Ceci est l'étape essentielle pour que Flask trouve vos fichiers HTML
+COPY templates /app/templates
+
+# Copie des autres fichiers (y compris app.py, votre point d'entrée)
+COPY app.py .
+COPY config.py .
+COPY user_routes.py .
+COPY web_routes.py .
+COPY decorators.py .
+COPY billing_routes.py .
+COPY auth_backend.py .
+COPY baserow_storage.py .
+
+# Copie du script d'entrée
+COPY entrypoint.sh .
+
+# NOUVEAU: CORRECTION DES FINS DE LIGNE (Résout 'exec ./entrypoint.sh: no such file or directory')
+# Supprime le caractère de retour chariot (\r)
+RUN sed -i 's/\r$//' entrypoint.sh
+
+# Le rendre exécutable
+RUN chmod +x entrypoint.sh
+
+# ÉTAPE 5: Sécurité et Exécution
+# Création et bascule vers l'utilisateur non-root ('user') pour la sécurité
+RUN useradd -ms /bin/bash user
+RUN chown -R user:user /app
+USER user
+
+# Indique à Docker que le conteneur écoute sur ce port
+EXPOSE $PORT
+
+# Lance l'application via le script d'entrée
+CMD ["./entrypoint.sh"]

app.py

@@ -0,0 +1,486 @@
+# 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

auth_backend.py

@@ -0,0 +1,359 @@
+# auth_backend.py
+
+import json
+import uuid
+import secrets 
+import string 
+import sys # Nécessaire pour print(..., file=sys.stderr)
+from datetime import datetime
+from werkzeug.security import generate_password_hash, check_password_hash
+# --- NOUVEL IMPORT: Migration vers Baserow ---
+# Ces fonctions sont maintenant implémentées dans baserow_storage.py
+from baserow_storage import (
+    # Fonctions de lecture/écriture pour les utilisateurs principaux (simulant l'ancienne API)
+    get_client_user_by_api_key,
+    get_end_user_by_email,
+    load_primary_user_data,
+    save_primary_user_data,
+    # Fonctions de recherche indexées (nouvelles et plus efficaces)
+    get_user_by_email,
+    get_client_user_by_api_key, 
+    # Fonctions de lecture/écriture pour les utilisateurs finaux (simulant l'ancienne API)
+    load_end_user_data, 
+    save_end_user_data, 
+    # load_users_data est désormais obsolète et retiré.
+)
+from flask import session 
+from config import PLANS_CONFIG 
+from typing import Optional, Dict 
+
+# ----------------------------------------------------------------------
+# --- Fonctions Utilitaires et de Configuration ---
+# ----------------------------------------------------------------------
+
+def get_plan_limit(plan: str) -> float: 
+    """Retourne la limite de compte pour un plan donné."""
+    return PLANS_CONFIG.get(plan, {}).get("limit", PLANS_CONFIG["free"]["limit"])
+
+def get_plan_details(plan_id: str) -> Optional[Dict]:
+    """Retourne les détails complets d'un plan à partir de son ID."""
+    return PLANS_CONFIG.get(plan_id)
+
+def generate_api_key(length: int = 32) -> str:
+    """Génère une clé API sécurisée."""
+    chars = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(chars) for _ in range(length))
+
+# ----------------------------------------------------------------------
+# --- Fonctions d'Authentification WEB (Primary Users) ---
+# ----------------------------------------------------------------------
+
+def register_user(username: str, email: str, password: str, confirm_password: str, security_question: str, security_answer: str) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Tente d'enregistrer un nouvel utilisateur principal.
+    Retourne l'ID utilisateur (str), un message (str), et les données utilisateur complètes (Dict) ou None.
+    """
+    email = email.lower().strip()
+    
+    # Validation du formulaire
+    if not all([username, email, password, confirm_password, security_question, security_answer]):
+        # Retourne (ID, message, Data)
+        return None, "Tous les champs sont requis.", None
+        
+    if password != confirm_password:
+        return None, "Les mots de passe ne correspondent pas.", None
+        
+    if len(password) < 8:
+        return None, "Le mot de passe est trop court (min 8 caractères).", None
+
+    # 1. Vérification de l'existence de l'utilisateur par email
+    if get_user_by_email(email):
+        return None, "Un compte avec cette adresse e-mail existe déjà.", None
+
+    # 2. Hachage des données
+    password_hash = generate_password_hash(password)
+    security_answer_hash = generate_password_hash(security_answer.lower())
+    
+    # 3. Création des données utilisateur
+    user_id = str(uuid.uuid4())
+    # Ligne optimisée: on génère les 5 clés en une seule liste
+    api_keys = [generate_api_key() for _ in range(5)] 
+    
+    new_user = {
+        'user_id': user_id,
+        'username': username,
+        'email': email,
+        'password_hash': password_hash,
+        # ASSIGNATION DES 5 CLÉS API AUX CHAMPS CORRESPONDANTS
+        'api_key': api_keys[0],
+        'api_key_2': api_keys[1],
+        'api_key_3': api_keys[2],
+        'api_key_4': api_keys[3],
+        'api_key_5': api_keys[4],
+        'security_question': security_question,
+        'security_answer_hash': security_answer_hash,
+        'plan_id': PLANS_CONFIG['free']['baserow_value'],
+        'stripe_subscription_id': None, # Pas d'abonnement Stripe au début
+        'date_creation': datetime.now().isoformat(),
+        'date_plan_start': datetime.now().isoformat(),
+        'api_calls_month': 0,
+        'status': 'Active',
+        'baserow_row_id': None, # Sera rempli par la fonction save_primary_user_data si c'est une création
+        # Note: D'autres champs pourraient être nécessaires ici, selon les besoins non-vus
+    }
+
+    # 4. Sauvegarde dans Baserow 
+    # La fonction save_primary_user_data mettra à jour 'baserow_row_id' dans new_user si la création est réussie.
+    success = save_primary_user_data(new_user, commit_msg=f"feat: Création de l'utilisateur {user_id} ({email})")
+    
+    if success:
+        # Retourne : ID utilisateur, message de succès, Dictionnaire utilisateur complet
+        return user_id, "Inscription réussie. Vous pouvez maintenant vous connecter.", new_user
+    else:
+        # Échec de l'écriture dans la BDD (Baserow)
+        # Retourne : None, message d'erreur, None
+        return None, "Erreur interne lors de l'enregistrement de l'utilisateur.", None
+
+        
+def login_user(username_or_email: str, password: str) -> tuple[Optional[str], str, Optional[Dict]]: # <-- NOUVEAU: Ajout de Optional[Dict] dans le type hint
+    """
+    Tente de connecter un utilisateur principal.
+    Retourne l'ID utilisateur (str), un message (str) et les données utilisateur (Dict).
+    """
+    username_or_email = username_or_email.lower().strip()
+    
+    # 1. Recherche de l'utilisateur par email (Utilisation de la nouvelle fonction rapide Baserow)
+    user = get_user_by_email(username_or_email)
+    
+    if user:
+        # 2. Vérification du mot de passe
+        if check_password_hash(user['password_hash'], password):
+            session['user_id'] = user['user_id']
+            # CORRECTION : Retourne 3 valeurs : ID, Message, Données Utilisateur
+            return user['user_id'], "Connexion réussie.", user 
+
+    # CORRECTION : Retourne 3 valeurs : None ID, Message, None Data
+    return None, "Email/Nom d'utilisateur ou mot de passe invalide.", None
+
+
+def get_user_by_id(user_id: str) -> Optional[Dict]:
+    """
+    Récupère un utilisateur principal par son ID.
+    Utilise la fonction load_primary_user_data (qui est get_user_by_id dans Baserow).
+    """
+    return load_primary_user_data(user_id)
+    
+def get_user_by_api_key(api_key: str) -> Optional[Dict]:
+    """
+    Récupère un utilisateur principal par sa Clé API (utilisé par le décorateur).
+    Utilise la nouvelle fonction indexée et rapide de Baserow.
+    """
+    return get_client_user_by_api_key(api_key)
+
+
+def reset_password_via_security_question(username_or_email: str, question: str, answer: str, new_password: str) -> tuple[bool, str]:
+    """Réinitialise le mot de passe via la question de sécurité."""
+    username_or_email = username_or_email.lower().strip()
+    
+    # Validation du mot de passe
+    if len(new_password) < 8:
+        return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+
+    # 1. Recherche de l'utilisateur
+    user = get_user_by_email(username_or_email)
+    
+    if not user:
+        return False, "Utilisateur introuvable."
+        
+    # 2. Vérification de la question/réponse
+    if user.get('security_question') != question:
+        return False, "Question de sécurité incorrecte."
+        
+    if not check_password_hash(user.get('security_answer_hash', ''), answer.lower()):
+        return False, "Réponse de sécurité incorrecte."
+        
+    # 3. Hachage du nouveau mot de passe
+    new_hashed_password = generate_password_hash(new_password)
+    
+    # 4. Mise à jour et sauvegarde en BDD (Baserow)
+    user['password_hash'] = new_hashed_password
+    
+    success = save_primary_user_data(user, commit_msg=f"feat: Réinitialisation MDP utilisateur {user['user_id']}")
+    
+    if success:
+        return True, "Mot de passe réinitialisé avec succès."
+    else:
+        return False, "Erreur interne lors de la mise à jour du mot de passe."
+
+
+def update_user_plan(user_id: str, new_plan_id: str, stripe_subscription_id: Optional[str]) -> bool:
+    """Met à jour le plan et l'ID d'abonnement Stripe pour un utilisateur."""
+    
+    user = get_user_by_id(user_id)
+    
+    if not user:
+        print(f"Erreur: Utilisateur {user_id} non trouvé pour la mise à jour du plan.", file=sys.stderr)
+        return False
+
+    user['plan_id'] = new_plan_id
+    user['stripe_subscription_id'] = stripe_subscription_id
+    user['date_plan_start'] = datetime.now().isoformat()
+    
+    success = save_primary_user_data(user, commit_msg=f"feat: Mise à jour du plan pour {user_id} vers {new_plan_id}")
+    
+    return success
+
+# ----------------------------------------------------------------------
+# --- Fonctions API (End Users) ---
+# ----------------------------------------------------------------------
+
+def register_end_user(client_user_id: str, email: str, username: str, password: str, security_question: Optional[str] = None, security_answer: Optional[str] = None, identifier: Optional[str] = None) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Tente d'enregistrer un nouvel utilisateur final pour un client donné.
+    Retourne l'ID utilisateur final (str), un message (str), et les données utilisateur complètes (Dict) ou None.
+    """
+    email = email.lower().strip()
+    
+    # 1. Validation de base
+    if not all([client_user_id, email, username, password]):
+        return None, "Les champs Client ID, Email, Nom d'utilisateur et Mot de passe sont requis.", None
+    
+    if len(password) < 8:
+        return None, "Le mot de passe est trop court (min 8 caractères).", None
+
+    # 2. Vérification de l'unicité de l'utilisateur final par email (scopé par client)
+    if get_end_user_by_email(client_user_id, email):
+        return None, "Un utilisateur final avec cette adresse e-mail existe déjà pour ce client.", None
+
+    # 3. Hachage des données
+    password_hash = generate_password_hash(password)
+    security_answer_hash = generate_password_hash(security_answer.lower()) if security_answer else None
+    
+    # 4. Création des données
+    end_user_id = str(uuid.uuid4())
+    
+    new_end_user = {
+        'end_user_id': end_user_id,
+        'client_user_id': client_user_id, # ID du client principal pour le lien
+        'identifier': identifier or email,
+        'email': email,
+        'username': username,
+        'password_hash': password_hash,
+        'security_question': security_question,
+        'security_answer_hash': security_answer_hash,
+        'status': 'Active',
+        'metadata': '{}', # Initialiser les métadonnées
+        'date_creation': datetime.now().isoformat(),
+        'baserow_row_id': None,
+    }
+
+    # 5. Sauvegarde dans Baserow 
+    success = save_end_user_data(new_end_user, commit_msg=f"feat: Création de l'utilisateur final {end_user_id}")
+    
+    if success:
+        return end_user_id, "Inscription de l'utilisateur final réussie.", new_end_user
+    else:
+        return None, "Erreur interne lors de l'enregistrement de l'utilisateur final.", None
+
+def login_end_user(client_user_id: str, email: str, password: str) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Tente de connecter un utilisateur final (End User) sous l'autorité d'un client principal (Primary User).
+    Retourne l'ID utilisateur final (str), un message (str) et les données utilisateur (Dict).
+    """
+    email = email.lower().strip()
+    
+    # 1. Recherche de l'utilisateur final par email et client ID
+    end_user = get_end_user_by_email(client_user_id, email)
+    
+    if end_user:
+        # 2. Vérification du mot de passe
+        if check_password_hash(end_user['password_hash'], password):
+            # Succès de la connexion.
+            return end_user['end_user_id'], "Connexion utilisateur final réussie.", end_user 
+
+    # Échec de l'authentification
+    return None, "Email ou mot de passe utilisateur final invalide pour ce client.", None
+
+def reset_end_user_password_by_client(client_user_id: str, end_user_id: str, new_password: str) -> tuple[bool, str]:
+    """
+    Permet à un client principal (Primary User) de réinitialiser le mot de passe
+    d'un de ses utilisateurs finaux (End User) par son ID (API client-side).
+    """
+    # 1. Validation du mot de passe
+    if len(new_password) < 8:
+        return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+
+    # 2. Charger les données de l'utilisateur final, en s'assurant qu'il appartient bien au client.
+    end_user_data = load_end_user_data(client_user_id, end_user_id)
+    
+    if not end_user_data:
+        # L'utilisateur final n'existe pas ou n'est pas lié à ce client_user_id
+        return False, "Utilisateur final introuvable ou non autorisé (n'appartient pas à ce client)."
+        
+    # 3. Hachage du nouveau mot de passe
+    new_password_hash = generate_password_hash(new_password)
+    
+    # 4. Mise à jour des données
+    end_user_data['password_hash'] = new_password_hash
+    
+    # 5. Sauvegarde des données
+    success = save_end_user_data(end_user_data, commit_msg=f"action: Réinitialisation du mot de passe de l'utilisateur final {end_user_id} par le client {client_user_id}")
+    
+    if success:
+        return True, "Mot de passe de l'utilisateur final réinitialisé avec succès."
+    else:
+        return False, "Erreur lors de la sauvegarde du nouveau mot de passe de l'utilisateur final."
+
+
+def update_user_profile(user_id: str, username: str, email: str, new_password: Optional[str] = None) -> tuple[bool, str]:
+    """
+    Met à jour le profil de l'utilisateur principal (client).
+    user_id: L'UUID de l'utilisateur.
+    username: Le nouveau nom d'utilisateur.
+    email: Le nouvel email.
+    new_password: Le nouveau mot de passe (si fourni et non vide).
+    """
+    
+    # 1. Chargement des données existantes
+    user_data = load_primary_user_data(user_id)
+    if not user_data:
+        return False, "Erreur critique : Utilisateur introuvable pour la mise à jour."
+        
+    original_email = user_data.get('email')
+    
+    # 2. Validation et mise à jour de l'email
+    if email and email != original_email:
+        # Vérification si le nouvel email n'est pas déjà utilisé par un autre utilisateur
+        # Note: get_user_by_email retourne l'objet utilisateur, pas juste l'ID.
+        existing_user_by_email = get_user_by_email(email)
+        
+        # S'il trouve un utilisateur ET que son ID ne correspond pas à l'utilisateur actuel,
+        # l'email est déjà pris.
+        if existing_user_by_email and existing_user_by_email.get('user_id') != user_id:
+            return False, "Cet email est déjà utilisé par un autre compte."
+        
+        # Mise à jour de l'email si la validation passe
+        user_data['email'] = email
+        
+    # 3. Mise à jour du nom d'utilisateur (pas de validation d'unicité assumée ici)
+    user_data['username'] = username
+    
+    # 4. Mise à jour du mot de passe (si un nouveau est fourni)
+    if new_password:
+        if len(new_password) < 8:
+            # Assurez-vous que cette limite est cohérente avec la fonction register_user
+            return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+            
+        user_data['password_hash'] = generate_password_hash(new_password)
+        
+    # 5. Sauvegarde des données
+    # Le row_id est stocké dans l'objet utilisateur après la première sauvegarde.
+    baserow_row_id = user_data.get('baserow_row_id')
+    
+    if baserow_row_id is None:
+        return False, "Erreur de configuration : ID de ligne Baserow manquant."
+        
+    if save_primary_user_data(user_data, commit_msg=f"feat: Mise à jour du profil utilisateur {user_id}"):
+        return True, "Votre profil a été mis à jour avec succès."
+    else:
+        return False, "Une erreur s'est produite lors de la sauvegarde du profil."

baserow_storage.py

@@ -0,0 +1,584 @@
+# baserow_storage.py
+
+import os
+import requests
+import json
+import sys
+from datetime import datetime
+from typing import Optional, Dict
+import logging
+# Configuration du logger (ajoutez ceci en haut du fichier)
+logger = logging.getLogger(__name__)
+# --- Configuration Baserow (Doit être défini dans les secrets) ---
+HEALTH_CHECK_URL = "https://api.baserow.io/api/database/rows/table/"
+
+# 2. URL de BASE CORRECTE pour la construction des requêtes de données (connexion, inscription, etc.)
+DATA_BASE_URL = "https://api.baserow.io/api/database/rows/"
+API_TOKEN = os.environ.get("BASEROW_API_TOKEN")
+
+# Les IDs de table seront récupérés depuis les variables d'environnement
+PRIMARY_USERS_TABLE_ID = os.environ.get("PRIMARY_USERS_TABLE_ID") 
+END_USERS_TABLE_ID = os.environ.get("END_USERS_TABLE_ID") 
+
+# Headers pour l'authentification
+HEADERS = {
+    "Authorization": f"Token {API_TOKEN}",
+    "Content-Type": "application/json"
+}
+
+# ----------------------------------------------------------------------
+# --- Noms de Colonnes pour la Table des Utilisateurs Principaux (Primary Users) ---
+# ----------------------------------------------------------------------
+FIELD_ID = 'ID' # Correspond à 'user_id' dans le code
+FIELD_EMAIL = 'Email' # Correspond à 'email'
+FIELD_USERNAME = 'Nom d\'utilisateur' # Correspond à 'username'
+FIELD_PASSWORD_HASH = 'Hachage Mot de Passe' # Correspond à 'password_hash'
+FIELD_API_KEY = 'Clé API' # Correspond à 'api_key'
+FIELD_API_KEY_2 = 'Clé API 2'
+FIELD_API_KEY_3 = 'Clé API 3'
+FIELD_API_KEY_4 = 'Clé API 4'
+FIELD_API_KEY_5 = 'Clé API 5'
+FIELD_SECURITY_Q = 'Question de Sécurité'
+FIELD_SECURITY_A_HASH = 'Hachage Réponse Secrète'
+FIELD_PLAN_ID = 'Plan ID'
+FIELD_STRIPE_SUB_ID = 'ID Abonnement Stripe'
+FIELD_DATE_CREATION = 'Date Création'
+FIELD_DATE_PLAN_START = 'Date Plan Start'
+FIELD_API_CALLS_MONTH = 'API Calls Month' # À vérifier avec votre nom exact dans Baserow!
+FIELD_STATUS = 'Status'
+FIELD_END_USER_ID = 'ID Utilisateur Final' # Correspond à 'end_user_id'
+FIELD_END_USER_IDENTIFIER = 'Identifiant' # Correspond à 'identifier'
+FIELD_END_USER_METADATA = 'Métadonnées' # Correspond à 'metadata'
+FIELD_CLIENT_ID_LINK = 'ID Client Principal' # Lien vers Primary_Users
+
+
+# ----------------------------------------------------------------------
+# --- Noms de Colonnes pour la Table des Utilisateurs Finaux (End Users) ---
+# ----------------------------------------------------------------------
+# Ces champs sont spécifiques à la table END_USERS
+FIELD_END_USER_ID = 'ID Utilisateur Final'
+FIELD_END_USER_IDENTIFIER = 'Identifiant' # Champ pour compatibilité ou recherche
+FIELD_END_USER_EMAIL = 'Email' # NOUVEAU
+FIELD_END_USER_USERNAME = 'Nom d\'utilisateur' # NOUVEAU
+FIELD_END_USER_SECURITY_Q = 'Question de Sécurité' # NOUVEAU (Peut être différent de Primary)
+FIELD_END_USER_SECURITY_A_HASH = 'Hachage Réponse Secrète' # NOUVEAU
+FIELD_END_USER_STATUS = 'Statut' # NOUVEAU
+FIELD_END_USER_METADATA = 'Métadonnées' 
+FIELD_PASSWORD_HASH_END_USER = 'Hachage Mot de Passe End User' # Renommer pour éviter le conflit si possible
+FIELD_CLIENT_ID_LINK = 'ID Client Principal'
+
+def _get_table_url(table_id: str) -> str:
+    """Construit l'URL d'API pour une table donnée (avec le bon endpoint)."""
+    return f"{DATA_BASE_URL}table/{table_id}/"
+
+def _baserow_record_to_user(record: Dict, is_end_user: bool) -> Dict:
+    """
+    Convertit un enregistrement Baserow (avec noms de champs utilisateur)
+    en format de dictionnaire Python attendu par le backend.
+    """
+    
+    # Si c'est un utilisateur final, utilisez la logique existante pour l'utilisateur final.
+    if is_end_user:
+        user_data = {
+            # Champs communs / End Users
+            'baserow_row_id': record['id'],
+            # Note: J'utilise FIELD_DATE_CREATION mais vous pouvez définir FIELD_END_USER_DATE_CREATION si Baserow a un nom de colonne différent.
+            'date_creation': record.get(FIELD_DATE_CREATION),
+            # End User specific fields (Ajout des NOUVEAUX champs)
+            'end_user_id': record.get(FIELD_END_USER_ID),
+            'identifier': record.get(FIELD_END_USER_IDENTIFIER),
+            'email': record.get(FIELD_END_USER_EMAIL), # NOUVEAU
+            'username': record.get(FIELD_END_USER_USERNAME), # NOUVEAU
+            'security_question': record.get(FIELD_END_USER_SECURITY_Q), # NOUVEAU
+            'security_answer_hash': record.get(FIELD_END_USER_SECURITY_A_HASH), # NOUVEAU
+            'status': record.get(FIELD_END_USER_STATUS), # NOUVEAU
+            
+            # CORRECTION CRUCIALE : Utilisation du nom de champ correct pour l'End User
+            'password_hash': record.get(FIELD_PASSWORD_HASH_END_USER), 
+            
+            # Le lien est un tableau, on extrait la valeur 'user_id' du client principal
+            'client_user_id': record.get(FIELD_CLIENT_ID_LINK)[0]['value'] if record.get(FIELD_CLIENT_ID_LINK) and record.get(FIELD_CLIENT_ID_LINK)[0]['value'] else None,
+            # Les métadonnées
+            'metadata': record.get(FIELD_END_USER_METADATA),
+        }
+        # Nettoyage des clés None ou non-pertinentes
+        return {k: v for k, v in user_data.items() if v is not None}
+        
+    # LOGIQUE POUR L'UTILISATEUR PRINCIPAL (PRIMARY USER)
+    
+    # 1. Récupération des champs individuels
+    user_data = {
+        # Champs communs / Primary Users
+        'baserow_row_id': record['id'], # ID interne de la ligne Baserow (pour les mises à jour)
+        'date_creation': record.get(FIELD_DATE_CREATION),
+        
+        # Primary User specific fields
+        'user_id': record.get(FIELD_ID),
+        'email': record.get(FIELD_EMAIL),
+        'username': record.get(FIELD_USERNAME),
+        'password_hash': record.get(FIELD_PASSWORD_HASH),
+        
+        # Récupération des 5 clés individuelles (pour l'authentification par clé)
+        'api_key': record.get(FIELD_API_KEY),
+        'api_key_2': record.get(FIELD_API_KEY_2),
+        'api_key_3': record.get(FIELD_API_KEY_3),
+        'api_key_4': record.get(FIELD_API_KEY_4),
+        'api_key_5': record.get(FIELD_API_KEY_5),
+        
+        'security_question': record.get(FIELD_SECURITY_Q),
+        'security_answer_hash': record.get(FIELD_SECURITY_A_HASH),
+        'plan_id': record.get(FIELD_PLAN_ID),
+        'stripe_subscription_id': record.get(FIELD_STRIPE_SUB_ID),
+        'date_plan_start': record.get(FIELD_DATE_PLAN_START),
+    }
+
+    # 2. ÉTAPE CRUCIALE AJOUTÉE : Création de la liste 'api_keys' pour l'affichage
+    # Cette liste est nécessaire pour que la boucle dans api_key.html fonctionne correctement.
+    user_data['api_keys'] = [
+        user_data['api_key'],
+        user_data['api_key_2'],
+        user_data['api_key_3'],
+        user_data['api_key_4'],
+        user_data['api_key_5'],
+    ]
+    
+    # Nettoyage des clés None ou non-pertinentes
+    return {k: v for k, v in user_data.items() if v is not None}
+
+
+def _user_to_baserow_data(user_data: Dict, is_end_user: bool) -> Dict:
+    """
+    Convertit le format de dictionnaire Python du backend en format
+    JSON attendu par l'API Baserow (avec noms de champs utilisateur).
+    """
+    if is_end_user:
+        # End User fields (Ajout des NOUVEAUX champs)
+        baserow_data = {
+            FIELD_END_USER_ID: user_data.get('end_user_id'),
+            FIELD_END_USER_IDENTIFIER: user_data.get('identifier'),
+            FIELD_END_USER_EMAIL: user_data.get('email'), # NOUVEAU
+            FIELD_END_USER_USERNAME: user_data.get('username'), # NOUVEAU
+            FIELD_END_USER_SECURITY_Q: user_data.get('security_question'), # NOUVEAU
+            FIELD_END_USER_SECURITY_A_HASH: user_data.get('security_answer_hash'), # NOUVEAU
+            FIELD_END_USER_STATUS: user_data.get('status'), # NOUVEAU
+            
+            # CORRECTION CRUCIALE : Utilisation du nom de champ correct pour l'End User
+            FIELD_PASSWORD_HASH_END_USER: user_data.get('password_hash'), 
+            
+            FIELD_END_USER_METADATA: user_data.get('metadata'),
+            FIELD_DATE_CREATION: user_data.get('date_creation'),
+            # Le lien vers Primary_Users est géré dans save_end_user_data
+        }
+    else:
+        # Primary User fields
+        baserow_data = {
+            FIELD_ID: user_data.get('user_id'),
+            FIELD_EMAIL: user_data.get('email'),
+            FIELD_USERNAME: user_data.get('username'),
+            FIELD_PASSWORD_HASH: user_data.get('password_hash'),
+            FIELD_API_KEY: user_data.get('api_key'),
+            FIELD_API_KEY_2: user_data.get('api_key_2'),
+            FIELD_API_KEY_3: user_data.get('api_key_3'),
+            FIELD_API_KEY_4: user_data.get('api_key_4'),
+            FIELD_API_KEY_5: user_data.get('api_key_5'),
+            FIELD_SECURITY_Q: user_data.get('security_question'),
+            FIELD_SECURITY_A_HASH: user_data.get('security_answer_hash'),
+            FIELD_PLAN_ID: user_data.get('plan_id'),
+            FIELD_STRIPE_SUB_ID: user_data.get('stripe_subscription_id'),
+            FIELD_DATE_CREATION: user_data.get('date_creation'),
+            FIELD_DATE_PLAN_START: user_data.get('date_plan_start'),
+            FIELD_API_CALLS_MONTH: user_data.get('api_calls_month', 0),
+            FIELD_STATUS: user_data.get('status', 'Active') # Assurez-vous que 'Active' est une option valide dans Baserow
+        }
+
+    # Suppression des clés non-valorisées (None)
+    return {k: v for k, v in baserow_data.items() if v is not None}
+
+
+def _get_single_user_record(table_id: str, field_name: str, value: str, is_end_user: bool) -> Optional[Dict]:
+    """Fonction générique pour rechercher un seul enregistrement par un champ (filtrage Baserow)."""
+    url = _get_table_url(table_id)
+    # Utilisation du paramètre de filtre de Baserow pour une recherche indexée (plus rapide)
+    filter_param = f"filter__{field_name}__equal={value}"
+    
+    try:
+        response = requests.get(
+            f"{url}?user_field_names=true&{filter_param}",
+            headers=HEADERS
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        if data and data.get('results'):
+            # On ne prend que le premier résultat (car ID/Email/API Key sont uniques)
+            return _baserow_record_to_user(data['results'][0], is_end_user)
+        return None
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Erreur de Baserow lors de la recherche par filtre {field_name}: {e}", file=sys.stderr)
+        return None
+
+# ----------------------------------------------------------------------
+# --- Fonctions CRUD Primary_Users (Nouveau et Remplacement) ---
+# ----------------------------------------------------------------------
+
+def get_user_by_email(email: str) -> Optional[Dict]:
+    """Recherche un utilisateur principal par son adresse Email."""
+    return _get_single_user_record(PRIMARY_USERS_TABLE_ID, FIELD_EMAIL, email, is_end_user=False)
+
+def get_client_user_by_api_key(api_key: str) -> Optional[Dict]:
+    """Recherche un utilisateur principal par sa Clé API."""
+    return _get_single_user_record(PRIMARY_USERS_TABLE_ID, FIELD_API_KEY, api_key, is_end_user=False)
+
+# Remplacement de l'ancien load_primary_user_data(user_id)
+def load_primary_user_data(user_id: str) -> Optional[Dict]:
+    """Recherche un utilisateur principal par son ID (user_id)."""
+    return _get_single_user_record(PRIMARY_USERS_TABLE_ID, FIELD_ID, user_id, is_end_user=False)
+
+
+def save_primary_user_data(user_data: Dict, commit_msg: str = "") -> bool:
+    """Crée ou met à jour un utilisateur principal, avec détection d'erreur ultra-précise."""
+    row_id = user_data.get('baserow_row_id')
+    
+    # Définition de l'URL de base pour la table des utilisateurs principaux
+    url = _get_table_url(PRIMARY_USERS_TABLE_ID)
+    
+    # 1. Conversion des données
+    baserow_data = _user_to_baserow_data(user_data, is_end_user=False)
+    
+    # 2. Suppression des champs en lecture seule (comme dans la correction précédente)
+    if baserow_data.pop(FIELD_ID, None):
+        print(f"DEBUG: Suppression du champ '{FIELD_ID}' (UUID auto) avant l'envoi { 'POST' if not row_id else 'PATCH'}.", file=sys.stderr)
+    
+    try:
+        # Détermination de l'action (PATCH ou POST)
+        if row_id:
+            action = "PATCH" # ⬅️ CORRECTION: Définition de 'action'
+            # MISE À JOUR (PATCH)
+            response = requests.patch(
+                f"{url}{row_id}/?user_field_names=true",
+                headers=HEADERS, 
+                json=baserow_data
+            )
+        else:
+            action = "POST" # ⬅️ CORRECTION: Définition de 'action'
+            # CRÉATION (POST)
+            response = requests.post(
+                f"{url}?user_field_names=true", # ⬅️ CORRECTION: Utilise l'URL de table 'url'
+                headers=HEADERS, 
+                json=baserow_data
+            )
+        
+        # Déclenche une exception requests.exceptions.HTTPError pour les statuts 4xx/5xx
+        response.raise_for_status() 
+        
+        # Succès
+        if not row_id:
+            new_record = response.json()
+            # 1. Mettre à jour l'ID de ligne Baserow
+            user_data['baserow_row_id'] = new_record.get('id')
+            # 2. Mettre à jour l'UUID de l'utilisateur (généré par Baserow)
+            user_data['user_id'] = new_record.get(FIELD_ID) 
+            
+            print(f"DEBUG: UUID de l'utilisateur généré par Baserow et enregistré: {user_data['user_id']}", file=sys.stderr)
+            
+        print(f"DEBUG: Baserow Primary User action '{action}' réussie. Row ID: {user_data.get('baserow_row_id')}. Message: {commit_msg}", file=sys.stderr)
+        return True
+        
+    except requests.exceptions.RequestException as e:
+        # --- BLOC DE DÉTECTION D'ERREUR PRÉCISE (Ultra-Complet) ---
+        
+        # Note: 'action' est définie dans le bloc try/except, mais si l'erreur survient 
+        # AVANT la définition de 'action', nous devons la gérer. 
+        # Pour être sûr, nous allons la définir ici par défaut si elle n'existe pas.
+        if 'action' not in locals():
+            action = "INCONNU"
+            
+        error_message = f"🚨 ÉCHEC: Erreur lors de la sauvegarde/mise à jour du Primary User dans Baserow. Requête: {action}"
+        error_details = ""
+
+        if hasattr(e, 'response') and e.response is not None:
+            # 1. Statut HTTP et URL
+            error_details += f"\n  -> STATUT HTTP: {e.response.status_code} ({e.response.reason})"
+            error_details += f"\n  -> URL de la requête: {e.response.url}"
+            
+            # 2. Tenter de décoder le corps de la réponse en JSON (contient les erreurs Baserow)
+            try:
+                response_json = e.response.json()
+                error_details += f"\n\n  -> ERREUR BASEROW DÉTAILLÉE (JSON):\n{json.dumps(response_json, indent=4)}"
+                
+                # Optionnel: Synthèse des erreurs de validation de champ
+                if isinstance(response_json, dict):
+                    validation_errors = {k: v for k, v in response_json.items() if isinstance(v, list) and k != 'detail'}
+                    if validation_errors:
+                        error_details += "\n  -> SYNTHÈSE DES CHAMPS INVALIDES (Vérifiez les noms de colonnes/IDs de table!):"
+                        for field_name, errors in validation_errors.items():
+                             error_details += f"\n    - Champ '{field_name}': {', '.join([err.get('error', 'Erreur inconnue') for err in errors])}"
+                    
+            except json.JSONDecodeError:
+                # 3. Si le corps de la réponse n'est pas du JSON
+                error_details += f"\n\n  -> ERREUR BRUTE (Réponse non-JSON):\n{e.response.text[:500]}..."
+
+        # 4. Afficher les données que nous avons tenté d'envoyer (après la suppression de l'ID si c'était une création)
+        error_details += f"\n\n  -> DONNÉES ENVOYÉES À BASEROW:\n{json.dumps(baserow_data, indent=4)}"
+        
+        # Log complet de l'erreur
+        print(error_message + error_details, file=sys.stderr)
+        
+        return False
+        
+        
+# ----------------------------------------------------------------------
+# --- Fonctions CRUD End_Users (Remplacement) ---
+# ----------------------------------------------------------------------
+
+# baserow_storage.py : Dans la section CRUD End_Users
+
+def get_end_user_by_email(client_user_id: str, email: str) -> Optional[Dict]:
+    """Recherche un utilisateur final par son Email, lié à un client principal (scope)."""
+    client_row_id = _get_client_baserow_row_id(client_user_id)
+    if not client_row_id:
+        print(f"Avertissement: Client Principal {client_user_id} introuvable pour la recherche de l'utilisateur final.", file=sys.stderr)
+        return None
+        
+    url = _get_table_url(END_USERS_TABLE_ID)
+    
+    # Filtre 1: Email de l'utilisateur final = email
+    # Filtre 2: Lien vers le Client Principal = client_row_id
+    filter_params = f"filter__{FIELD_END_USER_EMAIL}__equal={email}&filter__{FIELD_CLIENT_ID_LINK}__link_row_id={client_row_id}"
+    
+    try:
+        response = requests.get(
+            f"{url}?user_field_names=true&{filter_params}",
+            headers=HEADERS
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        if data and data.get('results'):
+            # On ne prend que le premier résultat
+            return _baserow_record_to_user(data['results'][0], is_end_user=True)
+        return None
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Erreur Baserow lors de la recherche End User par Email: {e}", file=sys.stderr)
+        return None
+
+def _get_client_baserow_row_id(client_user_id: str) -> Optional[int]:
+    """Récupère l'ID de ligne interne Baserow du client principal pour le lien."""
+    client_user = load_primary_user_data(client_user_id) # utilise la fonction déjà créée
+    return client_user.get('baserow_row_id') if client_user else None
+
+
+# Remplacement de l'ancien load_end_user_data(client_user_id, end_user_id)
+def load_end_user_data(client_user_id: str, end_user_id: str) -> Optional[Dict]:
+    """Recherche un utilisateur final par ID, lié à un client principal (recherche indexée)."""
+    client_row_id = _get_client_baserow_row_id(client_user_id)
+    if not client_row_id:
+        return None
+        
+    url = _get_table_url(END_USERS_TABLE_ID)
+    
+    # Filtre 1: ID Utilisateur Final = end_user_id
+    # Filtre 2: ID Client Principal (Lien) = client_row_id (Lien vers une autre table)
+    filter_params = f"filter__{FIELD_END_USER_ID}__equal={end_user_id}&filter__{FIELD_CLIENT_ID_LINK}__link_row_id={client_row_id}"
+    
+    try:
+        response = requests.get(
+            f"{url}?user_field_names=true&{filter_params}",
+            headers=HEADERS
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        if data and data.get('results'):
+            return _baserow_record_to_user(data['results'][0], is_end_user=True)
+        return None
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Erreur Baserow lors de la recherche End User: {e}", file=sys.stderr)
+        return None
+
+
+# Remplacement de l'ancien save_end_user_data(end_user_data)
+def save_end_user_data(end_user_data: Dict, commit_msg: str = "") -> bool:
+    """Crée ou met à jour un utilisateur final."""
+    row_id = end_user_data.get('baserow_row_id')
+    client_user_id = end_user_data.get('client_user_id')
+    
+    # Étape cruciale: Trouver l'ID de ligne Baserow du client principal
+    client_row_id = _get_client_baserow_row_id(client_user_id)
+    if not client_row_id:
+        print(f"Erreur: Client Principal {client_user_id} introuvable pour la sauvegarde de l'utilisateur final.", file=sys.stderr)
+        return False
+        
+    url = _get_table_url(END_USERS_TABLE_ID)
+    
+    # 1. Conversion des données
+    baserow_data = _user_to_baserow_data(end_user_data, is_end_user=True)
+    
+    # Ajout du lien vers le client principal (obligatoire pour la création/mise à jour)
+    # L'API Baserow pour les champs de type 'Lien vers une autre table' attend une liste d'ID de ligne.
+    baserow_data[FIELD_CLIENT_ID_LINK] = [client_row_id]
+    
+    try:
+        if row_id:
+            # MISE À JOUR (PATCH)
+            response = requests.patch(
+                f"{url}{row_id}/?user_field_names=true", 
+                headers=HEADERS, 
+                json=baserow_data
+            )
+        else:
+            # CRÉATION (POST)
+            response = requests.post(
+                f"{url}?user_field_names=true", 
+                headers=HEADERS, 
+                json=baserow_data
+            )
+        
+        response.raise_for_status()
+        
+        if not row_id and response.status_code == 200:
+            new_record = response.json()
+            end_user_data['baserow_row_id'] = new_record.get('id')
+            
+        print(f"DEBUG: Baserow End User action réussie. Row ID: {row_id or new_record.get('id')}. Message: {commit_msg}", file=sys.stderr)
+        return True
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Erreur lors de la sauvegarde/mise à jour du End User dans Baserow: {e}", file=sys.stderr)
+        return False
+
+def check_baserow_connection() -> str:
+    """
+    Vérifie l'état de connexion de la base de données Baserow.
+    Retourne 'operational' ou 'outage'.
+    """
+    # Liste des IDs de tables critiques à vérifier
+    CRITICAL_TABLE_IDS = [
+        PRIMARY_USERS_TABLE_ID, 
+        END_USERS_TABLE_ID
+    ]
+    
+    if not API_TOKEN:
+        # Si le token API n'est pas défini, échec immédiat
+        print("DEBUG: BASEROW_API_TOKEN manquant.", file=sys.stderr)
+        return "outage" 
+
+    for table_id in CRITICAL_TABLE_IDS:
+        if not table_id:
+            # Si un des IDs de table critiques n'est pas défini, échec
+            print(f"DEBUG: Un ID de table critique Baserow est manquant (ID: {table_id}).", file=sys.stderr)
+            return "outage"
+
+        # Tenter de faire un appel très léger (récupérer la première ligne)
+        # On utilise page_size=1 pour minimiser la charge
+        url = f"{DATA_BASE_URL}table/{table_id}/?page_size=1"
+        
+        try:
+            response = requests.get(url, headers=HEADERS, timeout=5)
+            
+            if response.status_code != 200:
+                # Si un 404, 403, ou autre erreur est retournée par Baserow pour CETTE table
+                print(f"DEBUG: Baserow check failed for table {table_id} with status code {response.status_code}", file=sys.stderr)
+                return "outage"
+                
+        except requests.exceptions.RequestException as e:
+            # Erreur de réseau (timeout, DNS, etc.)
+            print(f"DEBUG: Baserow connection error for table {table_id}: {e}", file=sys.stderr)
+            return "outage"
+            
+    # Si toutes les tables critiques ont été vérifiées avec succès
+    return "operational"
+
+
+def get_health_status() -> Dict:
+    """
+    Collecte l'état de santé de tous les services pour la page /statut.
+    """
+    
+    db_status = check_baserow_connection()
+    
+    # L'état de l'authentification et de l'API principale sont 
+    # généralement liés à l'état de la DB pour une application simple.
+    # Si la DB est HS, l'auth est HS. Sinon, ils sont OK.
+    
+    auth_status = db_status # Lié à la DB (pour charger les utilisateurs)
+    api_endpoint_status = "operational" # L'endpoint Flask lui-même est considéré comme OK s'il tourne
+    
+    # Version du service (pour information)
+    service_version = os.environ.get("SERVICE_VERSION", "1.0.0 (Baserow)")
+
+
+    return {
+        # Ces valeurs correspondent aux attributs 'data-status' dans statut.html
+        "auth": auth_status, 
+        "data_storage": db_status, 
+        "api_endpoint": api_endpoint_status,
+        "version": service_version,
+        "last_update": datetime.now().strftime("%Y-%m-%d %H:%M:%S UTC")
+    }
+
+def is_baserow_up() -> bool:
+    """
+    Vérifie l'état de Baserow en utilisant l'URL qui garantit un statut 100% fonctionnel
+    sur Hugging Face, SANS utiliser la fonction de construction d'URL de table.
+    """
+    try:
+        # Envoie une requête GET à l'URL qui répond positivement pour le health check.
+        response = requests.get(
+            HEALTH_CHECK_URL,
+            headers=HEADERS,
+            timeout=5
+        )
+        # On vérifie si la réponse est un succès (code 200).
+        return response.status_code == 200
+    except requests.exceptions.RequestException as e:
+        print(f"DEBUG: Baserow health check failed: {e}")
+        return False
+
+def log_baserow_api_call(method: str, url: str, headers: Dict, data: Optional[Dict] = None, log_response: bool = True):
+    """
+    Fonction utilitaire pour effectuer des appels API à Baserow et journaliser 
+    les requêtes et les réponses dans les logs du Space Hugging Face.
+    """
+    
+    # 1. Journalisation de la requête
+    logger.info(f"BASEROW REQUEST: {method} {url}")
+    # ATTENTION: Ne pas logger le token API complet!
+    logged_headers = {k: v.replace(API_TOKEN, '[TOKEN_MASKED]') if k == 'Authorization' else v for k, v in headers.items()}
+    logger.debug(f"BASEROW REQUEST Headers: {logged_headers}")
+    if data:
+        # Pour les requêtes POST/PUT, logger les données (sans le hash du mot de passe si possible)
+        logged_data = data.copy() if isinstance(data, dict) else data
+        if isinstance(logged_data, dict) and 'Hachage du mot de passe' in logged_data:
+             logged_data['Hachage du mot de passe'] = '[PASSWORD_HASH_MASKED]'
+        logger.debug(f"BASEROW REQUEST Body: {logged_data}")
+    
+    # 2. Exécution de la requête
+    try:
+        if method == "GET":
+            response = requests.get(url, headers=headers)
+        elif method == "POST":
+            response = requests.post(url, headers=headers, json=data)
+        elif method == "PUT":
+            response = requests.put(url, headers=headers, json=data)
+        elif method == "DELETE":
+            response = requests.delete(url, headers=headers)
+        else:
+            raise ValueError(f"Méthode HTTP non supportée: {method}")
+        
+        # 3. Journalisation de la réponse
+        if log_response:
+            logger.info(f"BASEROW RESPONSE: Status {response.status_code}")
+            # Journaliser le contenu pour les erreurs
+            if response.status_code >= 400:
+                logger.error(f"BASEROW ERROR RESPONSE Body: {response.text}")
+                
+        # 4. Retourner la réponse
+        return response
+        
+    except requests.exceptions.RequestException as e:
+        logger.error(f"BASEROW CONNECTION ERROR: {e}")
+        return None # Retourne None en cas d'erreur de connexion non gérée par le statut HTTP

billing_routes.py

@@ -0,0 +1,137 @@
+# billing_routes.py
+
+import os
+import stripe
+import json
+from flask import Blueprint, request, jsonify, Response, session, current_app, url_for
+from decorators import login_required 
+from auth_backend import get_user_by_id, get_plan_details, update_user_plan
+import traceback
+
+# Initialisation de Stripe avec la clé secrète
+# La clé sera lue depuis les variables d'environnement (secrets HF)
+stripe.api_key = os.environ.get("STRIPE_SECRET_KEY")
+
+# Création du Blueprint 'billing_bp'
+billing_bp = Blueprint('billing_bp', __name__)
+
+# --- Route API pour créer la session de paiement (Phase 3) ---
+@billing_bp.route("/api/create-checkout-session", methods=["POST"])
+@login_required
+def create_checkout_session():
+    """
+    Crée une session de checkout Stripe pour un plan donné.
+    """
+    data = request.get_json()
+    # Le plan_id doit être l'ID complet (ex: 'standard_monthly' ou 'illimited_annual')
+    final_plan_id = data.get('plan_id') 
+    user_id = session.get('user_id')
+    
+    plan_details = get_plan_details(final_plan_id)
+    
+    # Détermination de l'ID de prix Stripe (utilise monthly ou annual selon ce qui est défini)
+    price_id = plan_details.get('price_id_monthly') or plan_details.get('price_id_annual')
+
+    # Vérification de l'existence du plan et de l'ID de prix Stripe
+    if not plan_details or not price_id:
+        if final_plan_id == 'free':
+             return jsonify({"message": "Ce plan est gratuit, pas de session de paiement requise.", "url": url_for('user_bp.dashboard')}), 200
+        
+        # Logique de sécurité/erreur si l'ID de prix est manquant pour un plan payant
+        current_app.logger.error(f"Erreur: ID de prix Stripe manquant pour le plan {final_plan_id}.")
+        return jsonify({"message": "Erreur de configuration du plan.", "status": "Error"}), 500
+
+    try:
+        # Création de la session de paiement Stripe
+        checkout_session = stripe.checkout.Session.create(
+            # Type de paiement pour les abonnements récurrents
+            mode='subscription', 
+            # Les IDs de prix Stripe
+            line_items=[
+                {
+                    'price': price_id, 
+                    'quantity': 1
+                }
+            ],
+            # URLs de redirection après paiement/annulation
+            # _external=True est crucial pour que Stripe puisse rediriger correctement
+            success_url=url_for('user_bp.dashboard', payment='success', _external=True),
+            cancel_url=url_for('web_bp.checkout', plan=final_plan_id, payment='cancel', _external=True),
+            
+            # Informations personnalisées CRITIQUES pour le Webhook
+            metadata={
+                'user_id': user_id,
+                'plan_id': final_plan_id, # L'ID de plan complet (e.g. 'standard_monthly')
+            },
+            # Laisse Stripe pré-remplir l'email du client (si on le souhaite)
+            # customer_email=get_user_by_id(user_id).get('email'), 
+        )
+        
+        # Retourne l'URL de la session Stripe au frontend
+        return jsonify({'url': checkout_session.url}), 200
+
+    except stripe.error.StripeError as e:
+        current_app.logger.error(f"Erreur Stripe lors de la création de session: {e}")
+        return jsonify({"message": f"Une erreur Stripe est survenue: {e.user_message}", "status": "Error"}), 400
+    except Exception as e:
+        # Log toutes les autres erreurs pour le diagnostic
+        current_app.logger.error(f"Erreur inattendue lors de la création de session: {e}\n{traceback.format_exc()}")
+        return jsonify({"message": "Erreur interne du serveur lors de la création de la session.", "status": "Error"}), 500
+
+
+# --- Route Webhook Stripe (Phase 4) ---
+@billing_bp.route('/webhook/stripe', methods=['POST'])
+def stripe_webhook():
+    """
+    Gère les événements envoyés par Stripe pour mettre à jour l'abonnement de l'utilisateur.
+    """
+    payload = request.data
+    sig_header = request.headers.get('stripe-signature')
+    endpoint_secret = os.environ.get("STRIPE_WEBHOOK_SECRET")
+
+    # 1. Vérification que le secret est bien configuré
+    if not endpoint_secret:
+        current_app.logger.error("Erreur de configuration: STRIPE_WEBHOOK_SECRET est manquant.")
+        return jsonify({'message': 'Erreur de configuration serveur.'}), 500
+
+    try:
+        # 2. Validation de la signature du Webhook
+        event = stripe.Webhook.construct_event(
+            payload, sig_header, endpoint_secret
+        )
+    except Exception as e:
+        current_app.logger.error(f"Erreur Webhook Stripe (Validation): {e}")
+        # Retourne 400 pour que Stripe sache qu'il ne doit pas retenter cet événement
+        return 'Invalid payload or signature', 400
+
+    # 3. Traitement des événements
+    if event['type'] == 'checkout.session.completed':
+        session_data = event['data']['object']
+        
+        # Récupération des métadonnées CRITIQUES
+        user_id = session_data.get('metadata', {}).get('user_id')
+        plan_id = session_data.get('metadata', {}).get('plan_id') # L'ID de plan complet (e.g. 'standard_monthly')
+        subscription_id = session_data.get('subscription') # L'ID d'abonnement Stripe
+        
+        if user_id and plan_id and subscription_id:
+            # Appel à la fonction de mise à jour de la base de données (Phase 4)
+            success = update_user_plan(user_id, plan_id, subscription_id)
+            
+            if success:
+                current_app.logger.info(f"SUCCESS: Utilisateur {user_id} mis à jour au plan {plan_id} (Sub ID: {subscription_id})")
+            else:
+                # Le paiement a eu lieu, mais la BDD n'a pas été mise à jour: CRITIQUE
+                current_app.logger.error(f"FAILURE: Échec de la mise à jour Git pour l'utilisateur {user_id} après paiement Stripe. Plan: {plan_id}")
+        else:
+             # Manque d'infos critiques dans le webhook
+             current_app.logger.error(f"FAILURE: Données critiques manquantes dans le webhook. Session ID: {session_data.get('id')}. User ID: {user_id}. Plan ID: {plan_id}")
+             # Retourne 200 pour éviter une boucle de ré-envoi par Stripe
+             return jsonify({'message': 'Données utilisateur critiques manquantes dans la session Stripe.'}), 200 
+             
+    # Vous pouvez ajouter d'autres événements si nécessaire (ex: 'customer.subscription.deleted')
+    # elif event['type'] == 'customer.subscription.deleted':
+    #     current_app.logger.info(f"INFO: Abonnement Stripe supprimé. ID de souscription: {event['data']['object'].get('id')}")
+
+
+    # Retourne une réponse pour accuser réception de l'événement (très important)
+    return jsonify({'status': 'success'}), 200

config.py

@@ -0,0 +1,114 @@
+# config.py
+
+# Fichier de configuration pour le backend ErnestMind 2.5
+import os
+
+# --- Configuration Baserow (Nouveau) ---
+# Clés à définir dans les secrets d'environnement Hugging Face Space
+BASEROW_DATABASE_ID = os.environ.get("BASEROW_DATABASE_ID") 
+PRIMARY_USERS_TABLE_ID = os.environ.get("PRIMARY_USERS_TABLE_ID") 
+END_USERS_TABLE_ID = os.environ.get("END_USERS_TABLE_ID")
+# Le token d'accès API
+BASEROW_API_TOKEN = os.environ.get("BASEROW_API_TOKEN")
+
+# --- Configuration Stripe (Paiement) ---
+# Clés à définir dans les secrets d'environnement Hugging Face Space
+STRIPE_SECRET_KEY = os.environ.get("STRIPE_SECRET_KEY")
+STRIPE_WEBHOOK_SECRET = os.environ.get("STRIPE_WEBHOOK_SECRET")
+# Clé Publique (utilisée par le Frontend, mais stockée ici pour référence)
+STRIPE_PUBLIC_KEY = os.environ.get("STRIPE_PUBLIC_KEY")
+
+# --- Dictionnaire de Prix Central (Phase 1) ---
+# Contient toutes les informations nécessaires pour le Frontend et le Backend.
+# Les 'price_id' doivent correspondre aux IDs créés dans Stripe.
+PLANS_CONFIG = {
+    # Plan Gratuit
+    "free": {
+        "title": "Gratuit",
+        "baserow_value": "Free", # <--- NOUVEAU: Mettre la valeur EXACTE attendue par Baserow (ex: GRATUIT, Free, etc.)
+        "description": "Idéal pour les tests et les petits projets.",
+        "limit": 500,
+        "price_monthly": 0.0,
+        "price_annual": 0.0,
+        "price_id_monthly": None, 
+        "price_id_annual": None,  
+        "currency": "EUR"
+    },
+    # Plan Standard - Mensuel
+    "standard_monthly": {
+        "title": "Standard (Mensuel)",
+        "description": "Pour les utilisateurs réguliers. Paiement mensuel.",
+        "limit": 1000,
+        "price_monthly": 19.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OvXXXXXXX", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Standard - Annuel
+    "standard_annual": {
+        "title": "Standard (Annuel)",
+        "description": "Pour les utilisateurs réguliers. Économisez 20% en payant à l'année.",
+        "limit": 1000,
+        "price_monthly": 0.0,
+        "price_annual": 199.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OwYYYYYYY", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Pro - Mensuel
+    "pro_monthly": {
+        "title": "Pro (Mensuel)",
+        "description": "Pour les professionnels et les projets importants. Paiement mensuel.",
+        "limit": 2000,
+        "price_monthly": 49.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OxZZZZZZZ", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Pro - Annuel
+    "pro_annual": {
+        "title": "Pro (Annuel)",
+        "description": "Pour les professionnels et les projets importants. Économisez 20% en payant à l'année.",
+        "limit": 2000,
+        "price_monthly": 0.0,
+        "price_annual": 499.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OyAAAAAAA", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Illimité - Mensuel
+    "illimited_monthly": {
+        "title": "Illimité (Mensuel)",
+        "description": "Sans aucune restriction, pour les grandes entreprises. Paiement mensuel.",
+        "limit": float('inf'),
+        "price_monthly": 99.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OzBBBBBBB", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Illimité - Annuel
+    "illimited_annual": {
+        "title": "Illimité (Annuel)",
+        "description": "Sans aucune restriction, pour les grandes entreprises. Économisez 20% en payant à l'année.",
+        "limit": float('inf'),
+        "price_monthly": 0.0,
+        "price_annual": 999.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OzAACCCCC", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Spécial pour les End-users (pas listé sur la page de prix)
+    "end_user": {
+        "title": "End-User",
+        "description": "Compte utilisateur créé par un client.",
+        "limit": 0,
+        "price_monthly": 0.0,
+        "price_annual": 0.0,
+        "price_id_monthly": None,
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+}

decorators.py

@@ -0,0 +1,57 @@
+# decorators.py
+
+from functools import wraps
+from flask import session, redirect, url_for, flash, request, jsonify # <-- AJOUT de request, jsonify
+
+# Import nécessaire pour le décorateur API (Importation paresseuse pour éviter les problèmes d'importation circulaire)
+import auth_backend 
+
+def login_required(f):
+    """
+    Décorateur pour les routes nécessitant une connexion (Web UI).
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        # Vérifie si l'ID utilisateur est dans la session
+        if session.get('user_id') is None:
+            flash("Vous devez être connecté pour accéder à cette page.", "error")
+            # Rediriger vers la route de connexion (qui est dans user_bp)
+            return redirect(url_for('user_bp.connexion'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+def api_key_required(f):
+    """
+    Décorateur pour les routes d'API nécessitant une clé API valide.
+    Récupère la clé API de l'en-tête 'X-API-Key' ou du paramètre de requête 'api_key'.
+    Injecte les données de l'utilisateur principal (client) dans la fonction décorée.
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        # 1. Récupérer la clé depuis l'en-tête ou les paramètres de requête
+        api_key = request.headers.get('X-API-Key')
+        if not api_key:
+            api_key = request.args.get('api_key') 
+
+        if not api_key:
+            return jsonify({
+                "message": "Authentification requise. Clé API manquante dans l'en-tête X-API-Key ou le paramètre api_key.", 
+                "status": "Unauthorized"
+            }), 401
+        
+        # 2. Valider la clé et récupérer l'utilisateur principal
+        # NOTE: Utilise l'import paresseux 'auth_backend.get_client_user_by_api_key'
+        client_user = auth_backend.get_client_user_by_api_key(api_key)
+
+        if not client_user:
+            return jsonify({
+                "message": "Clé API invalide ou non reconnue.", 
+                "status": "Forbidden"
+            }), 403
+            
+        # 3. Injecter les données de l'utilisateur principal (le client)
+        kwargs['client_user'] = client_user
+        
+        return f(*args, **kwargs)
+
+    return decorated_function

requirements.txt

@@ -0,0 +1,10 @@
+# requirements.txt
+flask
+bcrypt
+requests
+gunicorn
+Flask-CORS
+python-dotenv
+stripe
+dnspython
+werkzeug

user_routes.py

@@ -0,0 +1,171 @@
+# user_routes.py
+
+from flask import Blueprint, render_template, request, redirect, url_for, session, flash, jsonify
+from auth_backend import (
+    register_user, 
+    login_user, 
+    reset_password_via_security_question, 
+    get_user_by_id,
+    update_user_profile,
+)
+from decorators import login_required 
+
+# Création du Blueprint 'user_bp' 
+user_bp = Blueprint('user_bp', __name__)
+
+@user_bp.route("/inscription", methods=['GET', 'POST'])
+def inscription():
+    if request.method == 'POST':
+        # Traitement du formulaire d'inscription
+        username = request.form.get("username")
+        email = request.form.get("email")
+        password = request.form.get("password")
+        confirm_password = request.form.get("confirm_password")
+        security_question = request.form.get("security_question")
+        security_answer = request.form.get("security_answer")
+
+        # CORRECTION ICI: Déballage des 3 valeurs. On utilise '_' pour la troisième (new_user_data)
+        user_id, message, _ = register_user(username, email, password, confirm_password, security_question, security_answer)
+
+        if user_id:
+            flash(message, "success")
+            # Rediriger vers la page de connexion après l'inscription
+            return redirect(url_for('user_bp.connexion'))
+        else:
+            flash(message, "error")
+            return render_template("inscription.html", 
+                                   username=username, 
+                                   email=email,
+                                   security_question=security_question, 
+                                   security_answer=security_answer)
+
+    return render_template("inscription.html")
+
+@user_bp.route("/connexion")
+def connexion():
+    return render_template("connexion.html")
+
+@user_bp.route("/deconnexion")
+@login_required
+def deconnexion():
+    # Déconnexion en vidant la session
+    session.pop('user_id', None)
+    flash("Vous êtes déconnecté avec succès.", "success")
+    # Redirection vers la page d'accueil ou de connexion
+    return redirect(url_for('web_bp.index')) 
+
+@user_bp.route("/mot-de-passe-oublie", methods=['GET', 'POST'])
+def mot_de_passe_oublie():
+    if request.method == 'POST':
+        username_or_email = request.form.get("username_or_email")
+        security_answer = request.form.get("security_answer")
+        new_password = request.form.get("new_password")
+        confirm_password = request.form.get("confirm_password")
+
+        # Validation rapide
+        if new_password != confirm_password:
+            flash("Les nouveaux mots de passe ne correspondent pas.", "error")
+            return render_template("mot_de_passe_oublie.html", username_or_email=username_or_email)
+        
+        success, message = reset_password_via_security_question(username_or_email, security_answer, new_password)
+        
+        if success:
+            flash(message, "success")
+            return redirect(url_for('user_bp.connexion'))
+        else:
+            flash(message, "error")
+            return render_template("mot_de_passe_oublie.html", username_or_email=username_or_email)
+            
+    return render_template("mot_de_passe_oublie.html")
+
+
+# --- Routes du Dashboard ---
+
+@user_bp.route("/dashboard")
+@login_required
+def dashboard():
+    """
+    Page du tableau de bord. Gère le message de succès de paiement (Phase 4).
+    """
+    user = get_user_by_id(session.get('user_id'))
+    
+    # Logique pour le succès de paiement
+    payment_status = request.args.get('payment')
+    
+    if payment_status == 'success':
+        # On flashe un message pour l'afficher via Jinja dans le dashboard.html
+        flash("Félicitations ! Votre abonnement a été activé avec succès.", "success")
+        # Redirection pour nettoyer l'URL du paramètre de paiement
+        return redirect(url_for('user_bp.dashboard'))
+        
+    return render_template("dashboard.html", user=user)
+
+
+@user_bp.route("/profile", methods=['GET', 'POST']) # <--- AJOUTER 'POST'
+@login_required
+def profile():
+    user_id = session.get('user_id')
+    
+    if request.method == 'POST':
+        # 1. Récupération des données du formulaire POST
+        username = request.form.get('username')
+        email = request.form.get('email')
+        new_password = request.form.get('new_password')
+        confirm_password = request.form.get('confirm_password')
+
+        # 2. Validation simple côté serveur
+        if not username or not email:
+            flash("Le nom d'utilisateur et l'e-mail sont obligatoires.", "error")
+        elif new_password and new_password != confirm_password:
+            flash("Le nouveau mot de passe et la confirmation ne correspondent pas.", "error")
+        else:
+            # 3. Appel de la fonction de mise à jour du backend
+            # Note : on passe None si le mot de passe n'est pas fourni/n'est pas validé.
+            password_to_update = new_password if new_password and new_password == confirm_password else None
+            
+            success, message = update_user_profile(user_id, username, email, password_to_update)
+            
+            if success:
+                flash(message, "success")
+                # On pourrait aussi rediriger vers la page /profile GET pour rafraîchir la vue
+                # et nettoyer l'URL.
+                return redirect(url_for('user_bp.profile')) 
+            else:
+                # Échec de la mise à jour (ex: email déjà pris, mot de passe trop court)
+                flash(message, "error")
+
+    # Logique pour la méthode GET ou après un échec POST
+    # On récupère toujours l'utilisateur pour l'affichage (s'assure des données les plus fraîches)
+    user = get_user_by_id(user_id) 
+    
+    if user is None:
+        # Erreur critique de session
+        flash("Erreur de session. Veuillez vous reconnecter.", "error")
+        session.pop('user_id', None) 
+        return redirect(url_for('user_bp.connexion'))
+        
+    return render_template("profile.html", user=user)
+
+
+@user_bp.route("/api-key", methods=['GET'])
+@login_required
+def api_key():
+    """
+    Affiche la page de gestion des clés API.
+    L'objet 'user' (retourné par get_user_by_id) contient maintenant la liste 'api_keys' (5 éléments).
+    """
+    user_id = session.get('user_id') # Récupération de l'ID depuis la session
+    user = get_user_by_id(user_id) # Appel à la fonction qui pourrait retourner None
+    
+    # --- CORRECTION DE L'ERREUR DÉTECTÉE DANS LES LOGS ---
+    if user is None:
+        # Si l'utilisateur n'est pas trouvé malgré le login_required (session corrompue)
+        flash("Erreur critique de session. Veuillez vous reconnecter.", "error")
+        # Forcer la déconnexion en vidant la session et rediriger vers la page de connexion
+        session.pop('user_id', None) 
+        # Si vous utilisez un logger, il faudrait logger cette erreur pour investigation
+        # current_app.logger.error(f"FAILURE: User ID {user_id} in session but not found in DB.")
+        return redirect(url_for('user_bp.connexion'))
+    # ----------------------------------------------------
+
+    return render_template("api_key.html", user=user)

web_routes.py

@@ -0,0 +1,80 @@
+# web_routes.py
+
+from flask import Blueprint, render_template, request, redirect, url_for
+from auth_backend import get_plan_details # Import nécessaire pour la route /checkout
+from baserow_storage import get_health_status
+
+# Création du Blueprint 'web_bp'
+web_bp = Blueprint('web_bp', __name__)
+
+@web_bp.route("/")
+def index():
+    """Page d'accueil."""
+    return render_template("index.html")
+
+@web_bp.route("/a-propos")
+def a_propos():
+    """Page À Propos."""
+    return render_template("a_propos.html")
+
+@web_bp.route("/documentation")
+def documentation():
+    """Page Documentation."""
+    return render_template("documentation.html")
+
+@web_bp.route("/tarifs")
+def tarifs():
+    """Page Tarifs."""
+    return render_template("tarifs.html")
+
+@web_bp.route("/checkout")
+def checkout():
+    """
+    Page de paiement. Récupère le plan ID de l'URL pour l'afficher.
+    """
+    # Récupère 'plan' du paramètre d'URL /checkout?plan=...
+    plan_id = request.args.get('plan') 
+    plan_details = get_plan_details(plan_id)
+    
+    # Si le plan n'existe pas, ou si le plan est 'free', rediriger vers la page des tarifs
+    if not plan_details or plan_id == 'free':
+        return redirect(url_for('web_bp.tarifs'))
+        
+    return render_template("checkout.html", plan_id=plan_id, plan=plan_details) 
+
+@web_bp.route("/support")
+def support():
+    """Page Support."""
+    return render_template("support.html")
+
+@web_bp.route("/mentions-legales")
+def mentions_legales():
+    """Page Mentions Légales."""
+    return render_template("mentions_legales.html")
+
+@web_bp.route("/politique-confidentialite")
+def politique_confidentialite():
+    """Page Politique de Confidentialité."""
+    return render_template("politique_confidentialite.html")
+
+@web_bp.route("/conditions-utilisation")
+def conditions_utilisation():
+    """Page Conditions d'Utilisation."""
+    return render_template("conditions_utilisation.html")
+
+@web_bp.route("/api_logs")
+def api_logs():
+    """Page Support."""
+    return render_template("api_logs.html")
+
+@web_bp.route("/statut")
+def statut():
+    """
+    Page pour afficher l'état/la santé de l'API en utilisant
+    la fonction de vérification d'état.
+    """
+    # 1. Appeler la fonction de vérification d'état
+    api_status_data = get_health_status()
+        
+    # 2. Passer la variable 'api_status' au template
+    return render_template("statut.html", api_status=api_status_data)