Upload 11 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,458 @@
+# 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,
+    # 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__) 
+
+# 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")
+
+    # Nouvelle ligne (pour recevoir le dictionnaire utilisateur):
+    user_id, message, new_user_data = register_user(username, email, password, confirm_password, security_question, security_answer)
+    # Note: new_user_data sera None en cas d'échec
+
+    if user_id:
+        session['user_id'] = user_id
+        # Supprimer l'appel à get_user_by_id qui échoue:
+        # user_data = get_user_by_id(user_id) <--- Ligne à retirer ou commenter
+
+        # Utiliser les données utilisateur que register_user a créées et nous a retournées
+        if new_user_data: # Vérifier si les données sont présentes (devrait l'être si user_id est présent)
+            user_data = new_user_data
+        else:
+            # En cas d'erreur de logique inattendue, user_data sera vide ou vous pouvez lever une erreur ici
+            # Pour le moment, utilisez un dictionnaire vide pour ne pas faire planter .get()
+            user_data = {} 
+
+        return jsonify({
+            "message": message, 
+            "status": "Success", 
+            "user_id": user_id, 
+            # user_data est maintenant soit new_user_data, soit {}
+            "api_key": user_data.get("api_key") 
+            }), 201
+    else: # Ce 'else' est maintenant correctement aligné avec le 'if user_id:'
+        return jsonify({"message": message, "status": "Error"}), 400
+
+
+
+@app.route("/api/login", methods=["POST"])
+def login():
+    data = request.get_json()
+    username = data.get("username") 
+    password = data.get("password")
+
+    # Mise à jour pour accepter les données utilisateur en plus de l'ID et du message
+    user_id, message, user_data = login_user(username, password)
+
+    # Note: user_data est maintenant la 3ème valeur retournée (ou None)
+    if user_id and user_data: # Vérifier user_data au lieu de le chercher
+        # Pas besoin d'appeler get_user_by_id(user_id) ici !
+        session['user_id'] = user_id
+        return jsonify({
+            "message": message, 
+            "status": "Success", 
+            "user_id": user_id, 
+            # Maintenant user_data n'est plus None
+            "api_key": user_data.get("api_key") 
+        }), 200
+    else:
+        # L'ancienne logique de retour d'erreur est correcte
+        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
+
+
+
+# --- Route de Vérification de l'État (API - Conservée) ---
+@app.route("/api/health", methods=["GET"])
+def health_check():
+    """Vérifie l'état du service (Git)."""
+    try:
+        load_users_data() # Tente de charger les données
+        git_status = "Ready"
+    except Exception:
+        git_status = "Failed (Vérifier HF_TOKEN)"
+        
+    return jsonify({
+        "status": "Online",
+        "data_storage": git_status
+    }), 200

auth_backend.py

@@ -0,0 +1,262 @@
+# 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)
+    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]:
+    """
+    Tente d'enregistrer un nouvel utilisateur principal.
+    Retourne l'ID utilisateur et un message.
+    """
+    email = email.lower().strip()
+    
+    # Validation du formulaire
+    if not all([username, email, password, confirm_password, security_question, security_answer]):
+        return None, "Tous les champs sont requis."
+        
+    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)."
+
+    # 1. Vérification de l'existence de l'utilisateur par email (Utilisation de la nouvelle fonction rapide Baserow)
+    if get_user_by_email(email):
+        return None, "Un compte avec cette adresse e-mail existe déjà."
+
+    # 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())
+    api_key = generate_api_key()
+    
+    new_user = {
+        'user_id': user_id,
+        'username': username,
+        'email': email,
+        'password_hash': password_hash,
+        'api_key': api_key,
+        'security_question': security_question,
+        'security_answer_hash': security_answer_hash,
+        'plan_id': 'free', # Plan par défaut
+        'stripe_subscription_id': None, # Pas d'abonnement Stripe au début
+        'date_creation': datetime.now().isoformat(),
+        'date_plan_start': datetime.now().isoformat(),
+        '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 
+    success = save_primary_user_data(new_user, commit_msg=f"feat: Création de l'utilisateur {user_id} ({email})")
+    
+    if success:
+        return user_id, "Inscription réussie. Vous pouvez maintenant vous connecter."
+    else:
+        # Échec de l'écriture dans la BDD (Baserow)
+        return None, "Erreur interne lors de l'enregistrement de l'utilisateur."
+
+
+def login_user(username_or_email: str, password: str) -> tuple[Optional[str], str]:
+    """
+    Tente de connecter un utilisateur principal.
+    Retourne l'ID utilisateur et un message.
+    """
+    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']
+            return user['user_id'], "Connexion réussie."
+
+    return None, "Email/Nom d'utilisateur ou mot de passe invalide."
+
+
+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, identifier: str, password: str, metadata: Optional[Dict] = None) -> tuple[Optional[str], str]:
+    """
+    Crée un nouvel utilisateur final pour le client API.
+    Retourne l'ID utilisateur final et un message.
+    """
+    if len(password) < 8:
+        return None, "Le mot de passe de l'utilisateur final est trop court (min 8 caractères)."
+        
+    # 1. Hachage
+    password_hash = generate_password_hash(password)
+    
+    # 2. Création des données utilisateur final
+    end_user_id = str(uuid.uuid4())
+    
+    new_end_user = {
+        'end_user_id': end_user_id,
+        'client_user_id': client_user_id, # Lien crucial vers le client principal
+        'identifier': identifier,
+        'password_hash': password_hash,
+        'metadata': json.dumps(metadata) if metadata else "{}", # Stockage JSON
+        'date_creation': datetime.now().isoformat(),
+        'baserow_row_id': None, # Sera rempli lors de la création
+    }
+
+    # 3. Sauvegarde dans Baserow. save_end_user_data doit gérer l'insertion.
+    success = save_end_user_data(new_end_user, commit_msg=f"feat: Création utilisateur final {end_user_id} pour client {client_user_id}")
+    
+    if success:
+        return end_user_id, "Utilisateur final créé avec succès."
+    else:
+        return None, "Erreur interne lors de la création de l'utilisateur final."
+
+def login_end_user(client_user_id: str, identifier: str, password: str) -> tuple[Optional[str], str]:
+    """Tente de connecter un utilisateur final."""
+    identifier = identifier.strip()
+    
+    # 1. Chargement de l'utilisateur final par ID + Client ID (Recherche indexée Baserow)
+    try:
+        end_user = load_end_user_data(client_user_id, identifier) # 'identifier' peut être l'UUID de l'utilisateur
+        if end_user and check_password_hash(end_user['password_hash'], password):
+            return identifier, "Connexion réussie."
+    except ValueError:
+        # Ce n'est pas un UUID. On retourne une erreur car la recherche par username/email n'est pas implémentée de manière performante.
+        pass 
+        
+    return None, "Identifiants utilisateur final invalides."
+
+def reset_end_user_password_by_client(client_user_id: str, end_user_id: str, new_password: str) -> tuple[bool, str]:
+    # Validation du mot de passe
+    if len(new_password) < 8:
+        return False, "Le nouveau mot de passe est trop court (min 8 caractères). Maintient l'ancienne limite."
+        
+    # Chargement de l'utilisateur final unique par ID
+    end_user = load_end_user_data(client_user_id, end_user_id)
+
+    if not end_user:
+        return False, "Utilisateur final introuvable pour ce client."
+        
+    # Hachage du nouveau mot de passe
+    new_hashed_password = generate_password_hash(new_password)
+    
+    # Mise à jour et sauvegarde en BDD (Baserow)
+    end_user['password_hash'] = new_hashed_password
+    
+    commit_msg = f"feat: Réinitialisation forcée MDP utilisateur final {end_user_id} par client {client_user_id}"
+    if save_end_user_data(end_user, commit_msg=commit_msg):
+        return True, "Mot de passe utilisateur final réinitialisé avec succès."
+    else:
+        return False, "Erreur interne lors de la réinitialisation du mot de passe utilisateur final."

baserow_storage.py

@@ -0,0 +1,287 @@
+# baserow_storage.py
+
+import os
+import requests
+import json
+import sys
+from typing import Optional, Dict
+
+# --- Configuration Baserow (Doit être défini dans les secrets) ---
+BASE_URL = "https://api.baserow.io/api/database/rows/" # Endpoint spécifique
+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 (Utilisés dans Baserow - basés sur la discussion précédente)
+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_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 Début Plan'
+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
+
+
+def _get_table_url(table_id: str) -> str:
+    """Construit l'URL d'API pour une table donnée (avec le bon endpoint)."""
+    return f"{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.
+    """
+    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),
+        'api_key': record.get(FIELD_API_KEY),
+        '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),
+    }
+
+    if is_end_user:
+        # End User specific fields
+        user_data['end_user_id'] = record.get(FIELD_END_USER_ID)
+        user_data['identifier'] = record.get(FIELD_END_USER_IDENTIFIER)
+        # Le lien est un tableau, on extrait la valeur 'user_id' du client principal
+        client_link = record.get(FIELD_CLIENT_ID_LINK)
+        # NOTE: Le format du lien renvoyé est [{... 'value': 'ID du client' ...}]
+        user_data['client_user_id'] = client_link[0]['value'] if client_link and client_link[0]['value'] else None 
+        # Les métadonnées sont stockées comme une chaîne JSON ou Texte Long
+        user_data['metadata'] = record.get(FIELD_END_USER_METADATA)
+        user_data['password_hash'] = record.get(FIELD_PASSWORD_HASH) # S'assurer qu'il est là pour l'utilisateur final
+        
+    # 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
+        baserow_data = {
+            FIELD_END_USER_ID: user_data.get('end_user_id'),
+            FIELD_END_USER_IDENTIFIER: user_data.get('identifier'),
+            FIELD_PASSWORD_HASH: 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_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'),
+        }
+
+    # 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."""
+    row_id = user_data.get('baserow_row_id')
+    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)
+    
+    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()
+        
+        # NOTE: Pour une création, il faut mettre à jour le baserow_row_id
+        if not row_id and response.status_code == 200:
+            new_record = response.json()
+            user_data['baserow_row_id'] = new_record.get('id')
+            
+        print(f"DEBUG: Baserow Primary 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 Primary User dans Baserow: {e}", file=sys.stderr)
+        return False
+        
+        
+# ----------------------------------------------------------------------
+# --- Fonctions CRUD End_Users (Remplacement) ---
+# ----------------------------------------------------------------------
+
+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

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,113 @@
+# 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",
+        "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

entrypoint.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+# entrypoint.sh
+
+# Afficher les commandes exécutées
+set -e
+
+echo "--- Démarrage de l'Application Gunicorn (Base de Données Baserow) ---"
+
+# Définir le port par défaut de Hugging Face si $PORT est vide
+export APP_PORT=${PORT:-7860} 
+
+# 1. Démarrer le serveur Flask/Gunicorn en premier plan (Plus besoin de process en arrière-plan)
+echo "Démarrage du serveur Gunicorn sur le port $APP_PORT..."
+# Utilisation de 'exec' pour que Gunicorn soit le PID 1, bonne pratique Docker.
+exec gunicorn --workers $GUNICORN_WORKERS --threads $GUNICORN_THREADS app:app -b 0.0.0.0:$APP_PORT

requirements.txt

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

user_routes.py

@@ -0,0 +1,114 @@
+# 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,
+)
+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")
+
+        # 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")
+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")
+@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")
+@login_required
+def api_key():
+    """Page d'affichage de la clé API unique. Retire la variable max_keys."""
+    user = get_user_by_id(session.get('user_id'))
+    return render_template("api_key.html", user=user)

web_routes.py

@@ -0,0 +1,62 @@
+# 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
+
+# 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")