Update baserow_storage.py

baserow_storage.py

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