Upload 12 files

.dockerignore

@@ -0,0 +1,20 @@
+# Fichiers invisibles de versionnement et d'IDE
+.git
+.gitattributes
+.gitignore
+.DS_Store
+
+# Exclure le Dockerfile et le .dockerignore lui-même (bonne pratique)
+Dockerfile
+.dockerignore
+
+# Exclure les dossiers de cache Python
+__pycache__/
+*.pyc
+
+# Exclure les dossiers de développement/log
+venv/         # Si vous avez un environnement virtuel
+env/          # Si vous avez un autre nom d'environnement virtuel
+logs/         # Dossiers de logs
+tmp/          # Dossiers temporaires
+*.log

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 git_storage.py .
+COPY user_routes.py .
+COPY data_committer.py .
+COPY decorators.py .
+COPY billing_routes.py .
+COPY auth_backend.py .
+COPY email_validator.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,135 @@
+# 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
+
+# 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,
+    update_user_quota # NOUVEL IMPORT (Phase 1)
+    # Suppression des fonctions end_users
+)
+from git_storage import load_users_data 
+from decorators import api_key_required, quota_required # <-- IMPORT de quota_required (Phase 2)
+
+# Importation du nouveau module de validation
+from email_validator import validate_email # NOUVEL IMPORT (Phase 2)
+
+# Importation des Blueprints
+from user_routes import user_bp, web_bp # <--- MISE À JOUR : Importe user_bp ET web_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__) 
+
+# Configuration
+app.secret_key = os.environ.get("FLASK_SECRET_KEY", "super_secret_default_key") # Clé Secrète pour Flask Session
+app.config['MAX_CONTENT_LENGTH'] = DEFAULT_MAX_CONTENT_LENGTH # Limite de la taille des requêtes
+CORS(app) # Autoriser les appels cross-domain
+
+# Enregistrement des Blueprints
+# Le Blueprint web_bp (routes publiques) est maintenant dans user_routes.py
+app.register_blueprint(web_bp) 
+app.register_blueprint(user_bp, url_prefix='/user') # Espace utilisateur (ex: /user/dashboard)
+app.register_blueprint(billing_bp, url_prefix='/billing') # Routes Stripe (ex: /billing/webhook)
+
+
+# --- Route API pour la validation d'e-mail (API) ---
+@app.route("/api/validate", methods=["POST"])
+@api_key_required
+@quota_required
+def api_validate_email(client_user):
+    """
+    Route principale de l'API de validation d'e-mail.
+    """
+    data = request.get_json()
+    email = data.get('email', '').strip()
+    
+    if not email:
+        return jsonify({
+            "message": "Le champ 'email' est manquant dans le corps de la requête.",
+            "status": "Bad Request"
+        }), 400
+        
+    # 1. Effectuer la validation
+    validation_result = validate_email(email)
+    
+    # 2. Décrémenter le quota si l'e-mail est valide ou s'il s'agit d'une erreur de domaine non jetable
+    # On ne décrémente PAS si la syntaxe est invalide ou si c'est un domaine jetable (pour ne pas gaspiller le quota sur des spams)
+    should_decrement = (validation_result['is_valid']) or (
+        not validation_result['details']['is_disposable'] and 
+        validation_result['details']['syntax_valid'] and 
+        not validation_result['details']['domain_valid'] # Erreur MX (domaine réel mais non configuré)
+    )
+    
+    if should_decrement:
+        if not update_user_quota(client_user['user_id']):
+            # Logique d'urgence: la mise à jour Git a échoué. Retourner une erreur 500.
+            return jsonify({
+                "message": "Erreur interne: Échec de la mise à jour du quota. Veuillez réessayer plus tard.",
+                "status": "Internal Error"
+            }), 500
+
+    # 3. Retourner la réponse
+    response_data = {
+        "email": email,
+        "is_valid": validation_result['is_valid'],
+        "reason": validation_result['reason'],
+        "details": validation_result['details'],
+        # Ajout du quota restant pour l'utilisateur
+        "new_quota": get_user_by_id(client_user['user_id']).get('quota', 0) 
+    }
+    
+    return jsonify({
+        "message": "Validation d'e-mail terminée.",
+        "status": "Success" if validation_result['is_valid'] else "Failed", 
+        "result": response_data
+    }), 200
+
+# --- Route API pour obtenir les infos utilisateur (API) ---
+@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, en se concentrant sur le QUOTA.
+    """
+    # Sécurité : créer une vue sécurisée des informations
+    user_info_safe = {
+        "user_id": client_user.get('user_id'),
+        "username": client_user.get('username'),
+        "plan": client_user.get('plan'),
+        "quota": client_user.get('quota'),
+        "api_key": client_user.get('api_key')
+    }
+    
+    return jsonify({
+        "message": "Informations de compte et quota récupérées avec succès.",
+        "status": "Success", 
+        "user": user_info_safe
+    }), 200
+
+
+# --- Route de Vérification de l'État (API - Conservée) ---
+@app.route("/api/health", methods=["GET"])
+def health_check():
+    """Vérifie que le serveur est opérationnel."""
+    return jsonify({"status": "ok", "message": "Le service est opérationnel."}), 200
+

auth_backend.py

@@ -0,0 +1,290 @@
+# auth_backend.py
+# (Contenu complet avec les fonctions existantes non modifiées, et la nouvelle fonction ajoutée)
+
+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
+from git_storage import (
+    # Fonctions de lecture/écriture pour les utilisateurs principaux (isolés)
+    load_primary_user_data, 
+    save_primary_user_data, 
+    # Temporairement conservé pour l'API Key Search sans index et les logins Web.
+    load_users_data, 
+)
+# Suppression des imports load_end_user_data et save_end_user_data
+from flask import session 
+from decorators import PLANS_CONFIG # <--- MISE À JOUR : Importe PLANS_CONFIG depuis decorators
+from typing import Optional, Dict 
+
+# ----------------------------------------------------------------------
+# --- NOUVELLES FONCTIONS DE GESTION DES CLÉS API (Phase 1 & 2) ---
+# ----------------------------------------------------------------------
+
+API_KEY_PREFIX = "NXS_"
+API_KEY_LENGTH = 48 # Nombre de caractères hexadécimaux (24 octets)
+
+def generate_api_key(user_id: str) -> str:
+    """
+    Génère une clé API sécurisée avec le préfixe NXS_.
+    Utilise secrets.token_hex pour une chaîne longue et aléatoire.
+    """
+    # 48 caractères hexadécimaux pour le corps de la clé (équivalent à 24 octets de données aléatoires)
+    # On pourrait inclure l'ID utilisateur dans le hachage pour une meilleure unicité, mais secrets.token_hex est suffisant.
+    random_part = secrets.token_hex(API_KEY_LENGTH // 2) 
+    return f"{API_KEY_PREFIX}{random_part}"
+
+def generate_initial_api_keys(user_id: str, count: int = 10) -> list[str]:
+    """Génère une liste de 10 nouvelles clés API pour un utilisateur."""
+    return [generate_api_key(user_id) for _ in range(count)]
+
+def regenerate_api_key(user_id: str, key_index: int) -> tuple[bool, str]:
+    """
+    Régénère une clé API spécifique pour un utilisateur donné (index 0 à 9).
+    """
+    # L'index doit être entre 0 et 9 (pour 10 clés)
+    if not 0 <= key_index < 10:
+        return False, "Index de clé invalide. Doit être entre 0 et 9."
+
+    user_data = load_primary_user_data(user_id)
+    
+    if not user_data:
+        return False, "Utilisateur principal introuvable."
+        
+    # S'assurer que la structure existe, sinon initialiser (pour les anciens utilisateurs)
+    if 'api_keys' not in user_data or len(user_data['api_keys']) != 10:
+         user_data['api_keys'] = generate_initial_api_keys(user_id, count=10)
+         
+    # Générer la nouvelle clé
+    new_key = generate_api_key(user_id)
+    
+    # Mise à jour de la clé spécifique dans la liste
+    user_data['api_keys'][key_index] = new_key
+    
+    # Sauvegarde en STAGING
+    commit_msg = f"feat: Régénération de la Clé API n°{key_index + 1} pour utilisateur {user_id}"
+    success = save_primary_user_data(user_id, user_data, commit_msg)
+    
+    if success:
+        return True, f"Clé API n°{key_index + 1} régénérée avec succès. Nouvelle clé: {new_key}"
+    else:
+        return False, "Échec de la sauvegarde des données utilisateur (problème Git)."
+
+
+# ----------------------------------------------------------------------
+# --- 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 get_user_by_id(user_id: str) -> Optional[Dict]:
+    """Récupère un utilisateur principal à partir de son ID (UUID)."""
+    if not user_id:
+        return None
+        
+    # Tente de charger l'utilisateur à partir du fichier isolé (méthode standard)
+    user_data = load_primary_user_data(user_id)
+    
+    if user_data:
+        return user_data
+    
+    # Fallback/Compatibilité : Lecture du fichier monolithique users.json
+    try:
+        users = load_users_data() 
+        return users.get(user_id)
+    except Exception:
+        return None
+        
+def get_user_by_email_or_username(identifier: str) -> Optional[Dict]:
+    """
+    Récupère un utilisateur principal à partir de son email ou de son nom d'utilisateur.
+    Nécessite la lecture du fichier users.json (lent et temporaire).
+    """
+    try:
+        users = load_users_data() 
+        for user_data in users.values():
+            if user_data['email'].lower() == identifier.lower() or user_data['username'].lower() == identifier.lower():
+                return user_data
+    except Exception:
+        pass 
+        
+    return None
+
+def get_client_user_by_api_key(api_key: str) -> Optional[Dict]:
+    """
+    Récupère les données d'un utilisateur (client) à partir de l'une de ses 10 clés API.
+    Nécessite la lecture du fichier users.json (lent et temporaire).
+    """
+    # 1. Vérification rapide du préfixe
+    if not api_key.startswith(API_KEY_PREFIX):
+        return None
+        
+    # 2. Chargement du fichier monolithique (TEMPORAIRE)
+    users = load_users_data() 
+    
+    # 3. Recherche de la clé dans la liste 'api_keys' de chaque utilisateur
+    for user_data in users.values():
+        # Utilise .get('api_keys', []) pour gérer les anciens utilisateurs sans la clé
+        if api_key in user_data.get('api_keys', []):
+            return user_data
+            
+    return None
+
+
+def generate_password_hash(password: str) -> str:
+    """Génère le hachage sécurisé du mot de passe."""
+    # Utilise l'algorithme par défaut (souvent sha256) avec un salt
+    return generate_password_hash(password)
+
+# ----------------------------------------------------------------------
+# --- Fonctions d'Authentification WEB (Utilisateurs Principaux) ---
+# ----------------------------------------------------------------------
+
+def register_user(username, email, password, confirm_password, security_question, security_answer) -> tuple[Optional[str], str]:
+    """Tente d'enregistrer un nouvel utilisateur principal et sauvegarde en STAGING."""
+    
+    # 1. Validation de base
+    if not all([username, email, password, confirm_password, security_question, security_answer]):
+        return None, "Tous les champs sont obligatoires."
+        
+    if password != confirm_password:
+        return None, "Les mots de passe ne correspondent pas."
+        
+    if len(password) < 8:
+        return None, "Le mot de passe est trop court (min 8 caractères)."
+
+    # 2. Vérification de l'existence
+    if get_user_by_email_or_username(email) or get_user_by_email_or_username(username):
+        return None, "Nom d'utilisateur ou email déjà utilisé."
+
+    # 3. Préparation des données
+    user_id = str(uuid.uuid4())
+    password_hash = generate_password_hash(password)
+    security_answer_hash = generate_password_hash(security_answer)
+    
+    # 4. MODÈLE DE DONNÉES MIS À JOUR (Phase 1.1)
+    new_user_data = {
+        'id': user_id,
+        'username': username,
+        'email': email,
+        'password_hash': password_hash,
+        'security_question': security_question,
+        'security_answer_hash': security_answer_hash,
+        'registration_date': datetime.now().isoformat(),
+        'plan': "free", # Plan par défaut
+        'usage_count': 0,
+        # NOUVEAU: Liste des 10 clés API (Phase 1.2)
+        'api_keys': generate_initial_api_keys(user_id, count=10), 
+    }
+
+    # 5. Sauvegarde des données en STAGING
+    commit_msg = f"feat: Nouvel utilisateur principal {email} enregistré"
+    success = save_primary_user_data(user_id, new_user_data, commit_msg)
+    
+    if success:
+        return user_id, "Inscription réussie. Vous pouvez maintenant vous connecter."
+    else:
+        # En cas d'échec de sauvegarde (très rare, mais possible)
+        return None, "Échec critique de l'inscription (problème de sauvegarde Git)."
+
+
+def login_user(identifier, password) -> tuple[Optional[str], str]:
+    """Tente de connecter un utilisateur principal par email ou username."""
+    
+    user = get_user_by_email_or_username(identifier)
+    
+    if user and check_password_hash(user['password_hash'], password):
+        # Connexion réussie, retourne l'ID
+        return user['id'], "Connexion réussie."
+    else:
+        return None, "Identifiants invalides."
+
+def reset_password_via_security_question(username_or_email, security_answer, new_password) -> tuple[bool, str]:
+    """Réinitialise le mot de passe après avoir validé la question de sécurité."""
+    
+    user = get_user_by_email_or_username(username_or_email)
+    
+    if not user:
+        return False, "Utilisateur introuvable."
+        
+    # Vérification de la réponse de sécurité
+    if check_password_hash(user['security_answer_hash'], security_answer):
+        
+        if len(new_password) < 8:
+            return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+            
+        # Mise à jour du mot de passe
+        user['password_hash'] = generate_password_hash(new_password)
+        
+        # Sauvegarde des données en STAGING
+        commit_msg = f"feat: Réinitialisation MDP pour {user['email']}"
+        success = save_primary_user_data(user['id'], user, commit_msg)
+        
+        if success:
+            return True, "Mot de passe réinitialisé avec succès. Vous pouvez maintenant vous connecter."
+        else:
+            return False, "Échec de la sauvegarde des données utilisateur (problème Git)."
+            
+    else:
+        return False, "Réponse à la question de sécurité incorrecte."
+        
+        
+def update_user_plan(user_id: str, new_plan: str, subscription_id: str) -> bool:
+    """Met à jour le plan de l'utilisateur principal et enregistre l'ID de souscription Stripe."""
+    user = load_primary_user_data(user_id)
+    
+    if not user:
+        print(f"ERROR: Tentative de mise à jour du plan pour l'utilisateur inconnu {user_id}", file=sys.stderr)
+        return False
+        
+    user['plan'] = new_plan
+    user['subscription_id'] = subscription_id # Stocke l'ID de la souscription Stripe
+    user['update_date'] = datetime.now().isoformat()
+    
+    commit_msg = f"feat: Mise à jour du plan de l'utilisateur {user_id} vers {new_plan}"
+    
+    return save_primary_user_data(user_id, user, commit_msg)
+
+# --- NOUVELLE FONCTION DE GESTION DU QUOTA (Phase 1) ---
+
+def update_user_quota(user_id: str, calls_to_decrement: int = 1) -> bool:
+    """
+    Décrémente le quota d'appels API de l'utilisateur principal.
+    
+    Args:
+        user_id (str): L'ID de l'utilisateur principal dont le quota doit être mis à jour.
+        calls_to_decrement (int): Le nombre d'appels à décrémenter (par défaut 1).
+        
+    Returns:
+        bool: True si la mise à jour en staging a réussi, False sinon.
+    """
+    # 1. Charger les données actuelles de l'utilisateur
+    user = load_primary_user_data(user_id)
+    
+    if not user:
+        print(f"ERREUR CRITIQUE: Tentative de mise à jour de quota pour utilisateur introuvable: {user_id}", file=sys.stderr)
+        return False
+
+    # 2. Vérifier si le plan est Illimité
+    if user['plan'].startswith('illimited'):
+        # Ne rien faire pour les plans illimités
+        return True 
+
+    # 3. Décrémenter le quota
+    # Assurer que le champ 'quota' existe et est un entier.
+    # On utilise max(0, ...) pour ne jamais passer en négatif, même si le quota était...
+    current_quota = user.get('quota', 0)
+    user['quota'] = max(0, current_quota - calls_to_decrement)
+    
+    # 4. Sauvegarder en staging (le committer s'occupera du commit Git)
+    commit_msg = f"quota: Décrémentation de {calls_to_decrement} appel(s) pour utilisateur {user_id}. Nouveau quota: {user['quota']}"
+    return save_primary_user_data(user_id, user, commit_msg)

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

data_committer.py

@@ -0,0 +1,120 @@
+# data_committer.py
+
+import os
+import json
+import time
+import sys
+import traceback
+from os import path, listdir, remove, makedirs
+from huggingface_hub import HfApi, CommitOperationAdd, CommitOperationDelete, hf_hub_download
+from huggingface_hub.errors import HfHubHTTPError
+from git_storage import get_authenticated_api, REPO_ID # Récupérer l'API et le REPO_ID
+
+# Configuration
+UNCOMMITTED_DATA_DIR = "uncommitted_data/"
+COMMIT_INTERVAL_SECONDS = 10 # Fréquence de vérification du dossier de staging
+MAX_RETRIES = 3 # Nombre de tentatives pour un commit échoué
+
+def get_staged_files():
+    """Retourne la liste complète des fichiers JSON dans le dossier de staging."""
+    try:
+        if not path.exists(UNCOMMITTED_DATA_DIR):
+            return []
+            
+        return [f for f in listdir(UNCOMMITTED_DATA_DIR) if f.endswith('.json')]
+    except Exception as e:
+        print(f"ERREUR: Échec de la lecture du répertoire de staging: {e}", file=sys.stderr)
+        return []
+
+def process_staged_file(api: HfApi, filename: str):
+    """Lit un fichier de staging, exécute le commit et supprime le fichier local."""
+    local_path = path.join(UNCOMMITTED_DATA_DIR, filename)
+    
+    try:
+        # 1. Lire le contenu du fichier de staging
+        with open(local_path, 'r', encoding='utf-8') as f:
+            payload = json.load(f)
+            
+        repo_file_path = payload.get("repo_file_path")
+        commit_message = payload.get("commit_message")
+        data = payload.get("data")
+        
+        if not repo_file_path or data is None:
+            print(f"ERREUR: Fichier de staging corrompu ou incomplet: {filename}. Suppression.", file=sys.stderr)
+            remove(local_path)
+            return
+
+        # 2. Préparer le fichier pour le commit (écrire dans un buffer/temp file)
+        data_to_commit = json.dumps(data, indent=4).encode('utf-8')
+        
+        # 3. Exécuter le commit atomique d'UN SEUL fichier
+        # On utilise une liste d'opérations pour le commit
+        operations = [
+            CommitOperationAdd(
+                path_in_repo=repo_file_path,
+                path_or_fileobj=data_to_commit
+            )
+        ]
+        
+        print(f"INFO: Committing de {repo_file_path} avec message: {commit_message}")
+        
+        # Appel API bloquant (assure la sérialisation)
+        api.create_commit(
+            repo_id=REPO_ID,
+            operations=operations,
+            commit_message=commit_message,
+            repo_type="dataset",
+        )
+        
+        print(f"SUCCESS: Commit de {repo_file_path} réussi.")
+        
+        # 4. Supprimer le fichier de staging local après le succès
+        remove(local_path)
+        print(f"INFO: Fichier local {filename} supprimé.")
+        
+    except HfHubHTTPError as e:
+        print(f"ERREUR HF HUB lors du commit de {filename} vers {repo_file_path}: {e}", file=sys.stderr)
+        # Ne pas supprimer le fichier, il sera réessayé au prochain cycle
+        
+    except Exception as e:
+        print(f"ERREUR INATTENDUE lors du traitement du fichier {filename}: {e}", file=sys.stderr)
+        traceback.print_exc()
+        # Supprimer si l'erreur n'est pas liée à Git (fichier corrompu, etc.)
+        if path.exists(local_path):
+             remove(local_path)
+
+
+def data_committer_loop():
+    """Boucle principale du processus de commit séquentiel."""
+    print("--- Processus Data Committer démarré ---")
+    try:
+        api = get_authenticated_api()
+    except ValueError as e:
+        print(f"ERREUR FATALE: {e}. Arrêt du committer.", file=sys.stderr)
+        return
+
+    while True:
+        try:
+            staged_files = get_staged_files()
+            if staged_files:
+                print(f"INFO: {len(staged_files)} fichiers en attente de commit. Début du traitement séquentiel.")
+                
+                # Traiter UN PAR UN pour garantir la sérialisation
+                for filename in staged_files:
+                    process_staged_file(api, filename)
+                    
+            else:
+                print("INFO: Aucun fichier en attente de commit.")
+
+        except Exception as e:
+            print(f"ERREUR MAJEURE dans la boucle principale du committer: {e}", file=sys.stderr)
+            traceback.print_exc()
+            
+        # Pause avant la prochaine vérification
+        time.sleep(COMMIT_INTERVAL_SECONDS)
+
+if __name__ == "__main__":
+    # Assurer que le dossier de staging existe au démarrage
+    if not path.exists(UNCOMMITTED_DATA_DIR):
+        makedirs(UNCOMMITTED_DATA_DIR)
+    data_committer_loop()

decorators.py

@@ -0,0 +1,162 @@
+# decorators.py (Contient maintenant la configuration du projet)
+
+# --- Contenu de config.py ---
+import os
+from functools import wraps
+from flask import session, redirect, url_for, flash, request, jsonify 
+
+# --- 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",
+        "description": "500 appels à l'API de validation d'e-mail par mois. Idéal pour les tests.", # MODIFIÉ
+        "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": "10,000 appels à l'API de validation d'e-mail par mois. Paiement mensuel.", 
+        "limit": 10000, 
+        "price_monthly": 49.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OxXXXXXXX", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Standard - Annuel
+    "standard_annual": {
+        "title": "Standard (Annuel)",
+        "description": "10,000 appels à l'API de validation d'e-mail par mois. Économisez 20% en payant à l'année.", # MODIFIÉ
+        "limit": 10000, 
+        "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": "Nombre d'appels illimité à l'API de validation d'e-mail. Paiement mensuel.", # MODIFIÉ
+        "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": "Nombre d'appels illimité à l'API de validation d'e-mail. Économisez 20% en payant à l'année.", # MODIFIÉ
+        "limit": float('inf'),
+        "price_monthly": 0.0,
+        "price_annual": 999.90,
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OzCCCCCCC", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+}
+
+# --- Contenu original de decorators.py (Imports ajustés en haut) ---
+
+# 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') or request.args.get('api_key')
+        
+        if not api_key:
+            return jsonify({
+                "message": "Clé API manquante. Fournissez 'X-API-Key' en en-tête ou 'api_key' en paramètre.",
+                "status": "Unauthorized"
+            }), 401
+            
+        # 2. Rechercher l'utilisateur associé à la clé
+        # Utilisation de la fonction load_user_by_api_key du module auth_backend
+        client_user = auth_backend.load_user_by_api_key(api_key)
+        
+        if not client_user:
+            return jsonify({
+                "message": "Clé API invalide ou inactive.",
+                "status": "Unauthorized"
+            }), 401
+            
+        # 3. Injecter l'objet utilisateur pour les décorateurs suivants (comme quota_required) et la fonction cible
+        kwargs['client_user'] = client_user
+        
+        return f(*args, **kwargs)
+    return decorated_function
+    
+
+def quota_required(f):
+    """
+    Décorateur pour les routes API nécessitant un quota d'appels positif.
+    Doit être placé APRÈS @api_key_required pour que client_user soit déjà injecté.
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        client_user = kwargs.get('client_user')
+        
+        # Le décorateur @api_key_required garantit la présence de client_user
+        if not client_user:
+             return jsonify({
+                "message": "Erreur interne: Impossible de vérifier le quota (utilisateur manquant).", 
+                "status": "Internal Error"
+            }), 500
+        
+        # Vérifier si le plan est illimité (float('inf'))
+        if client_user['plan'].startswith('illimited'):
+            return f(*args, **kwargs)
+            
+        # Vérifier le quota standard
+        current_quota = client_user.get('quota', 0)
+        
+        if current_quota > 0:
+            return f(*args, **kwargs)
+        else:
+            # Plan non-illimité et quota épuisé
+            return jsonify({
+                "message": "Quota d'appels API épuisé. Veuillez mettre à jour votre plan.",
+                "status": "Forbidden",
+                "current_quota": current_quota
+            }), 403
+            
+    return decorated_function

email_validator.py

@@ -0,0 +1,103 @@
+# email_validator.py
+
+import re
+import dns.resolver 
+from typing import Dict, Any
+
+# NOTE: Pour que dns.resolver fonctionne, vous devez vous assurer que la librairie 'dnspython'
+# est installée dans votre environnement (par exemple, dans requirements.txt).
+
+# Liste statique de quelques domaines jetables courants (exemple)
+DISPOSABLE_DOMAINS = {
+    "mailinator.com",
+    "yopmail.com",
+    "temp-mail.org",
+    "trash-mail.com",
+}
+
+# Regex pour la vérification de la syntaxe de base d'un e-mail
+# (Bon compromis pour une validation web/API)
+EMAIL_REGEX = re.compile(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
+
+
+def check_syntax(email: str) -> bool:
+    """Vérifie la syntaxe de l'e-mail à l'aide d'une expression régulière."""
+    return bool(EMAIL_REGEX.fullmatch(email))
+
+
+def check_mx_record(domain: str) -> bool:
+    """
+    Vérifie l'existence d'un enregistrement MX (Mail Exchange) pour le domaine.
+    Indique si le domaine est configuré pour recevoir des e-mails.
+    """
+    try:
+        # Tente de résoudre l'enregistrement MX
+        answers = dns.resolver.resolve(domain, 'MX')
+        # S'il y a des réponses, le domaine peut recevoir des e-mails
+        return len(answers) > 0
+    except dns.resolver.NXDOMAIN:
+        # Le domaine n'existe pas
+        return False
+    except dns.resolver.NoAnswer:
+        # Le domaine existe, mais n'a pas d'enregistrement MX
+        return False
+    except Exception as e:
+        # Autres erreurs (timeout, etc.) - On assume un échec pour la sécurité
+        print(f"Erreur DNS lors de la vérification MX pour {domain}: {e}")
+        return False
+
+
+def is_disposable(domain: str) -> bool:
+    """Vérifie si le domaine est dans la liste des domaines jetables."""
+    return domain.lower() in DISPOSABLE_DOMAINS
+
+
+def validate_email(email: str) -> Dict[str, Any]:
+    """
+    Moteur principal de validation d'e-mail.
+    """
+    email = email.strip()
+    
+    # 1. Vérification de la syntaxe
+    if not check_syntax(email):
+        return {
+            "is_valid": False,
+            "reason": "Syntaxe invalide.",
+            "details": {"syntax_valid": False, "domain_valid": False, "is_disposable": False}
+        }
+        
+    # Séparer le nom d'utilisateur et le domaine
+    try:
+        _, domain = email.split('@', 1)
+    except ValueError:
+        return {
+            "is_valid": False,
+            "reason": "Format d'e-mail incorrect.",
+            "details": {"syntax_valid": False, "domain_valid": False, "is_disposable": False}
+        }
+    
+    # 2. Vérification des domaines jetables
+    is_disposable_domain = is_disposable(domain)
+    if is_disposable_domain:
+        return {
+            "is_valid": False,
+            "reason": "Domaine jetable détecté.",
+            "details": {"syntax_valid": True, "domain_valid": True, "is_disposable": True}
+        }
+        
+    # 3. Vérification de l'enregistrement MX
+    is_domain_valid = check_mx_record(domain)
+    
+    if not is_domain_valid:
+        return {
+            "is_valid": False,
+            "reason": "Domaine invalide (pas d'enregistrement MX trouvé).",
+            "details": {"syntax_valid": True, "domain_valid": False, "is_disposable": False}
+        }
+        
+    # 4. Succès (e-mail valide)
+    return {
+        "is_valid": True,
+        "reason": "E-mail valide.",
+        "details": {"syntax_valid": True, "domain_valid": True, "is_disposable": False}
+    }

entrypoint.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# entrypoint.sh
+
+# Afficher les commandes exécutées
+set -e
+
+echo "--- Démarrage de l'Application Gunicorn et du Data Committer ---"
+
+# Définir le port par défaut de Hugging Face si $PORT est vide
+# Utiliser 7860 qui est le port par défaut de Hugging Face Spaces
+export APP_PORT=${PORT:-7860} 
+
+# 1. Démarrer le serveur Flask/Gunicorn en arrière-plan
+# Le paramètre $APP_PORT est maintenant garanti d'avoir une valeur
+echo "Démarrage du serveur Gunicorn sur le port $APP_PORT..."
+gunicorn --workers $GUNICORN_WORKERS --threads $GUNICORN_THREADS app:app -b 0.0.0.0:$APP_PORT &
+
+# Capturer le PID du processus Gunicorn
+GUNICORN_PID=$!
+echo "Gunicorn démarré avec PID: $GUNICORN_PID"
+
+# 2. Démarrer le committer en arrière-plan
+echo "Démarrage du Data Committer..."
+python data_committer.py &
+
+# Capturer le PID du processus Committer
+COMMITTER_PID=$!
+echo "Data Committer démarré avec PID: $COMMITTER_PID"
+
+# 3. Attendre que l'un des processus en arrière-plan se termine
+# Si l'un des processus meurt, le container doit s'arrêter pour éviter un état zombie.
+wait -n $GUNICORN_PID $COMMITTER_PID

git_storage.py

@@ -0,0 +1,125 @@
+# git_storage.py
+
+import json
+import traceback
+from huggingface_hub import HfApi, CommitOperationAdd, hf_hub_download
+from os import environ, path, makedirs
+from huggingface_hub.errors import HfHubHTTPError
+import sys
+from datetime import datetime
+import io
+import uuid # Ajout pour la génération de noms de fichiers uniques
+
+# Configuration du dépôt
+REPO_ID = "ernestmindres/database_mailix" # Assurez-vous que c'est votre Repo ID
+
+# --- NOUVELLE STRUCTURE DE DONNÉES ISOLÉE ET DE STAGING ---
+# Dossiers de destination dans le Dataset après commit
+PRIMARY_USERS_DIR = "primary_users/" 
+# END_USERS_DIR est supprimé (logique utilisateur final)
+
+# Dossier de staging local pour les fichiers non committés
+UNCOMMITTED_DATA_DIR = "uncommitted_data/"
+
+
+# --- Fonctions Utilitaires Générales ---
+def get_authenticated_api():
+    """Vérifie le jeton et retourne un objet HfApi."""
+    current_token = environ.get("HF_TOKEN")
+    if not current_token:
+        raise ValueError("Erreur d'authentification: Le secret HF_TOKEN est manquant ou non chargé.")
+    return HfApi(token=current_token)
+
+def load_file_from_repo(repo_file_path: str, default_content=None) -> dict:
+    """Tente de télécharger et lire un fichier JSON à partir du Dataset Hugging Face."""
+    local_filename = path.basename(repo_file_path)
+    try:
+        # Télécharger le fichier de manière paresseuse (lazy)
+        download_path = hf_hub_download(
+            repo_id=REPO_ID, 
+            filename=repo_file_path, 
+            repo_type="dataset"
+        )
+        with open(download_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except HfHubHTTPError as e:
+        # 404 est normal pour les nouveaux fichiers/utilisateurs
+        if '404' in str(e):
+            return default_content or {}
+        print(f"ERREUR HTTP lors du chargement de {repo_file_path}: {e}", file=sys.stderr)
+    except Exception as e:
+        print(f"ERREUR lors du chargement de {repo_file_path}: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+    return default_content or {}
+
+
+def _save_to_staging(repo_file_path: str, data: dict, commit_message: str):
+    """
+    Écrit un fichier JSON en local dans le dossier de staging (uncommitted_data/)
+    et inclut les métadonnées de commit.
+    """
+    try:
+        # Assurer que le dossier de staging existe
+        if not path.exists(UNCOMMITTED_DATA_DIR):
+            makedirs(UNCOMMITTED_DATA_DIR)
+
+        # Créer un nom de fichier unique pour le staging
+        # Format: {timestamp}_{uuid}.json (pour éviter les collisions)
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        unique_filename = f"{timestamp}_{uuid.uuid4().hex}.json"
+        local_staging_path = path.join(UNCOMMITTED_DATA_DIR, unique_filename)
+
+        # Les métadonnées de commit sont stockées avec les données
+        staging_data = {
+            "repo_file_path": repo_file_path,
+            "commit_message": commit_message,
+            "content": data
+        }
+
+        with open(local_staging_path, 'w', encoding='utf-8') as f:
+            json.dump(staging_data, f, indent=4)
+            
+        print(f"INFO: Fichier mis en staging pour commit: {repo_file_path}")
+        return True
+    
+    except Exception as e:
+        print(f"ERREUR lors de la mise en staging de {repo_file_path}: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+        return False
+
+
+# --- Fonctions Spécifiques aux Utilisateurs Principaux (Clients) ---
+
+def _get_primary_user_file_path(user_id):
+    """Retourne le chemin complet du fichier JSON d'un utilisateur principal dans le Dataset."""
+    # Chemin: primary_users/{user_id}.json
+    return path.join(PRIMARY_USERS_DIR, f"{user_id}.json")
+
+
+def load_primary_user_data(user_id: str) -> dict:
+    """Charge les données d'un seul utilisateur principal à partir de son fichier dédié."""
+    file_path = _get_primary_user_file_path(user_id)
+    return load_file_from_repo(file_path, default_content=None)
+
+
+def save_primary_user_data(user_id: str, user_data: dict, commit_message: str = "feat: Mise à jour utilisateur principal via API/Web") -> bool:
+    """Enregistre les données d'un utilisateur principal en staging pour un commit ultérieur."""
+    repo_file_path = _get_primary_user_file_path(user_id)
+    return _save_to_staging(repo_file_path, user_data, commit_message)
+
+
+# --- Fonction Temporairement Conservée (Lecture Lente) ---
+# Nécessaire pour les logins Web et la recherche de clé API sans index/cache
+def load_users_data() -> dict:
+    """
+    Charge l'ancienne structure monolithique pour la recherche d'API Key/Login Web.
+    À migrer vers un index/cache de tous les fichiers primary_users/{user_id}.json.
+    """
+    # Ce code est conservé pour la rétrocompatibilité (lecture lente)
+    file_path = "users.json"
+    data = load_file_from_repo(file_path, default_content={"users": {}})
+    # Avertissement dans la console
+    if not data:
+      print("ATTENTION: Chargement de l'ancien fichier users.json (lecture lente). Migrer vers index/cache.", file=sys.stderr)
+    return data
+

requirements.txt

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

user_routes.py

@@ -0,0 +1,196 @@
+# user_routes.py (Contient maintenant toutes les routes web/UI)
+
+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,
+    get_plan_details, # <--- AJOUT pour les routes web publiques (ex: /checkout)
+)
+from decorators import login_required 
+
+# Création du Blueprint 'user_bp' (Routes utilisateur: inscription, connexion, dashboard, etc.)
+user_bp = Blueprint('user_bp', __name__)
+
+@user_bp.route("/inscription", methods=['GET', 'POST'])
+def inscription():
+# ... (Contenu inchangé des routes /inscription, /connexion, /deconnexion, /mot-de-passe-oublie)
+    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")
+
+        # Appel à register_user mis à jour pour inclure la génération de clé API
+        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", methods=['GET', 'POST'])
+def connexion():
+    if request.method == 'POST':
+        username_or_email = request.form.get("username_or_email")
+        password = request.form.get("password")
+        
+        user_id, message = login_user(username_or_email, password)
+        
+        if user_id:
+            # Stocker l'ID utilisateur dans la session
+            session['user_id'] = user_id
+            flash(message, "success")
+            return redirect(url_for('user_bp.dashboard'))
+        else:
+            flash(message, "error")
+            return render_template("connexion.html", username_or_email=username_or_email)
+            
+    return render_template("connexion.html")
+
+@user_bp.route("/deconnexion")
+def deconnexion():
+    # Nettoyer la session (supprimer l'ID utilisateur)
+    session.pop('user_id', None)
+    flash("Vous avez été déconnecté avec succès.", "success")
+    # Rediriger vers la page d'accueil ou de connexion
+    return redirect(url_for('web_bp.index')) # Assurez-vous d'utiliser le nom du Blueprint public
+
+@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")
+        new_password = request.form.get("new_password")
+        confirm_password = request.form.get("confirm_password")
+        security_answer = request.form.get("security_answer")
+        
+        success, message = reset_password_via_security_question(username_or_email, new_password, confirm_password, security_answer)
+        
+        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")
+@login_required
+def profile():
+    user = get_user_by_id(session.get('user_id'))
+    return render_template("profile.html", user=user)
+
+@user_bp.route("/api-key-logs")
+@login_required
+def api_key_logs():
+    user = get_user_by_id(session.get('user_id'))
+    # NOTE: L'implémentation de la lecture des logs d'API n'est pas détaillée ici,
+    # mais cette route sert de point d'entrée pour l'interface.
+    return render_template("api_logs.html", user=user)
+    
+@user_bp.route("/api-key-management")
+@login_required
+def api_key_management():
+    """
+    Page de gestion de la clé API.
+    """
+    user = get_user_by_id(session.get('user_id'))
+    # NOTE: Les fonctions de révocation/régénération de clé ne sont pas détaillées ici,
+    # mais la clé peut être affichée.
+    return render_template("api_key.html", user=user)
+
+
+# ----------------------------------------------------------------------
+# --- ROUTES WEB PUBLIQUES (Contenu de web_routes.py) ---
+# ----------------------------------------------------------------------
+
+# Création du Blueprint 'web_bp' pour les routes publiques
+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':
+        # Note: L'appel url_for utilise 'web_bp.tarifs' car cette fonction est dans le blueprint web_bp
+        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("/conditions-utilisation")
+def conditions_utilisation():
+    """Page Conditions d'utilisation."""
+    return render_template("conditions_utilisation.html")
+    
+@web_bp.route("/politique-confidentialite")
+def politique_confidentialite():
+    """Page Politique de Confidentialité."""
+    return render_template("politique_confidentialite.html")