Add application file

Dockerfile

@@ -0,0 +1,23 @@
+# Utiliser une image Python officielle comme base
+FROM python:3.10-slim
+
+# Définir le répertoire de travail dans le conteneur
+WORKDIR /app
+
+# Copier le fichier des dépendances dans le conteneur
+COPY requirements.txt .
+
+# Mettre à jour pip
+RUN pip install --upgrade pip
+
+# Installer les dépendances
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copier le reste de l'application dans le conteneur
+COPY . .
+
+# Exposer le port Streamlit (par défaut 8501)
+EXPOSE 7860
+
+# Définir la commande pour exécuter l'application Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,1570 @@
+import os
+import pytz
+import json
+import uuid
+import base64
+import streamlit as st
+from supabase import create_client, Client
+import requests
+import bcrypt
+import jwt
+from dotenv import load_dotenv
+import functools
+from datetime import datetime, timedelta
+from datetime import datetime
+from io import BytesIO
+from PIL import Image
+import time
+import traceback
+from functools import lru_cache
+import extra_streamlit_components as stx
+from contextlib import contextmanager
+from typing import Dict, List, Optional, Tuple, Any
+from typing import TypedDict, Union
+from utils.password_reset import initiate_password_reset
+from utils.notification_handler import notify_security_alert #import du module de notifications (fonction alerte d'une nouvelle connexio)
+from utils.notification_handler import send_daily_summary #import du module de notifications (fonction du résumé quotidien, voire la fonction def generate_user_summary(user_id: int) dans ce fichier)
+from utils.email_utils import send_email
+import secrets # Concerne l'email de vérification lors de l'inscription d'un nouvels utilisateur
+import logging # gardez l'import de logging même si nous n'utilisons plus directement ses fonctions de log, car nous avons toujours besoin de ses constantes de niveau (level=logging.INFO/ERROR/WARNING)
+from utils.logging_utils import log_to_file # système de logging défini sur un fichier séparé pour une meilleure lisibilité.
+from utils.theme_utils import (
+    save_theme_preference,
+    load_theme_preference,
+    apply_theme,
+    inject_custom_css,
+    add_sidebar_logo,
+    apply_chat_styles,
+    inject_custom_toggle_css,
+    create_custom_footer,
+    theme_switcher,
+    remove_streamlit_style,
+    force_streamlit_style_update,
+    hide_pages
+)
+import asyncio
+from utils.async_flowise import AsyncFlowiseClient
+from utils.cache_manager import CacheManager
+from admin_page import render_admin_dashboard
+import tracemalloc
+tracemalloc.start()
+from utils.auth_cache import AuthenticationCache # Importation de la classe d'authentification
+auth_cache = AuthenticationCache() # Créez une instance globale de AuthenticationCache pour utiliser ses focntions d'authentification et de cache au sein de l'application
+from utils.ip_utils import get_user_ip
+
+
+
+
+
+
+
+
+
+st.set_page_config(
+    page_title="Colibri - Votre assistant intelligent",  # ou un titre approprié
+    page_icon=":bar_chart:",
+    layout="wide",
+)
+# Initialisez le cache manager globalement
+cache_manager = CacheManager()
+# Charger les variables d'environnement
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+JWT_SECRET = os.getenv("JWT_SECRET")
+FLOWISE_API_URL_SANTE = os.getenv("FLOWISE_API_URL_SANTE")
+FLOWISE_API_URL_CAR = os.getenv("FLOWISE_API_URL_CAR")
+FLOWISE_API_URL_BTP = os.getenv("FLOWISE_API_URL_BTP")
+FLOWISE_API_URL_RH = os.getenv("FLOWISE_API_URL_RH")
+FLOWISE_API_URL_PILOTAGE = os.getenv("FLOWISE_API_URL_PILOTAGE")
+
+# Configuration du logging
+
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+# ===============================================================================
+# début de l'implémentation des focntions de génération du résumé quatidien pour envoyer une notification à l'utilisateur ayant activé cette notif
+
+def start_activity_tracking(user_id: int):
+    """Démarre une nouvelle session de tracking d'activité"""
+    try:
+        # Vérifier s'il existe déjà une session active
+        active_tracking = supabase.table("user_activity_tracking").select("*").eq(
+            "user_id", user_id
+        ).is_("session_end", None).execute()
+
+        if not active_tracking.data:
+            # Créer une nouvelle session de tracking
+            supabase.table("user_activity_tracking").insert({
+                "user_id": user_id,
+                "session_start": datetime.now(pytz.UTC).isoformat(),
+                "date_tracked": datetime.now(pytz.UTC).date().isoformat()
+            }).execute()
+
+    except Exception as e:
+        log_to_file(f"Erreur lors du démarrage du tracking : {str(e)}", level=logging.ERROR)
+
+def end_activity_tracking(user_id: int):
+    """Termine la session de tracking active"""
+    try:
+        # Récupérer la session active
+        active_tracking = supabase.table("user_activity_tracking").select("*").eq(
+            "user_id", user_id
+        ).is_("session_end", None).execute()
+
+        if active_tracking.data:
+            tracking = active_tracking.data[0]
+            session_start = datetime.fromisoformat(tracking['session_start'].replace('Z', '+00:00'))
+            session_end = datetime.now(pytz.UTC)
+            duration = int((session_end - session_start).total_seconds() / 60)
+
+            # Mettre à jour la session
+            supabase.table("user_activity_tracking").update({
+                "session_end": session_end.isoformat(),
+                "duration_minutes": duration
+            }).eq("id", tracking['id']).execute()
+
+    except Exception as e:
+        log_to_file(f"Erreur lors de la fin du tracking : {str(e)}", level=logging.ERROR)
+
+def calculate_usage_time(user_id: int) -> int:
+    """Calcule le temps total d'utilisation en minutes pour la journée"""
+    try:
+        today = datetime.now(pytz.UTC).date()
+
+        # Récupérer toutes les sessions terminées de la journée
+        completed_sessions = supabase.table("user_activity_tracking").select(
+            "duration_minutes"
+        ).eq("user_id", user_id).eq(
+            "date_tracked", today.isoformat()
+        ).not_.is_("session_end", None).execute()
+
+        # Calculer le temps des sessions terminées
+        total_minutes = sum(
+            session.get('duration_minutes', 0)
+            for session in completed_sessions.data
+            if session.get('duration_minutes') is not None
+        )
+
+        # Ajouter le temps de la session active si elle existe
+        active_session = supabase.table("user_activity_tracking").select("*").eq(
+            "user_id", user_id
+        ).is_("session_end", None).execute()
+
+        if active_session.data:
+            session_start = datetime.fromisoformat(
+                active_session.data[0]['session_start'].replace('Z', '+00:00')
+            )
+            current_time = datetime.now(pytz.UTC)
+            active_duration = int((current_time - session_start).total_seconds() / 60)
+            total_minutes += active_duration
+
+        return total_minutes
+
+    except Exception as e:
+        log_to_file(f"Erreur lors du calcul du temps d'utilisation : {str(e)}", level=logging.ERROR)
+        return 0
+
+def generate_user_summary(user_id: int):
+    """Génère et envoie un résumé quotidien à l'utilisateur"""
+    try:
+        today = datetime.now(pytz.UTC).date()
+
+        # Compter les conversations et messages
+        conversations = get_conversation_count(user_id)
+        messages = get_messages_count(user_id)
+        usage_time = calculate_usage_time(user_id)  # Utilise la nouvelle méthode
+
+        summary_data = {
+            "conversations": conversations,
+            "questions": messages,
+            "usage_time": usage_time
+        }
+
+        # Envoyer le résumé
+        send_daily_summary(user_id, summary_data)
+
+    except Exception as e:
+        log_to_file(f"Erreur lors de la génération du résumé : {str(e)}", level=logging.ERROR)
+
+def check_and_send_daily_summary():
+    """Vérifie et envoie le résumé quotidien si nécessaire"""
+    try:
+        if 'user' in st.session_state and 'last_summary_sent' not in st.session_state:
+            user_id = st.session_state['user']['id']
+
+            # Récupérer les préférences de notification
+            prefs = supabase.table("notification_preferences").select("*").eq("user_id", user_id).execute()
+
+            if prefs.data and prefs.data[0].get('daily_summary'):
+                # Générer et envoyer le résumé
+                summary_data = {
+                    "conversations": get_conversation_count(user_id),
+                    "questions": get_messages_count(user_id),
+                    "usage_time": calculate_usage_time(user_id)
+                }
+
+                if send_daily_summary(user_id, summary_data):
+                    # Marquer comme envoyé pour aujourd'hui
+                    st.session_state['last_summary_sent'] = datetime.now(pytz.UTC).date()
+                    log_to_file(f"Résumé quotidien envoyé avec succès pour l'utilisateur {user_id}", level=logging.INFO)
+                else:
+                    log_to_file(f"Échec de l'envoi du résumé quotidien pour l'utilisateur {user_id}", level=logging.ERROR)
+
+    except Exception as e:
+        log_to_file(f"Erreur lors de la vérification du résumé quotidien : {str(e)}", level=logging.ERROR)
+
+def get_conversation_count(user_id: int) -> int:
+    """Compte le nombre de conversations de la journée"""
+    try:
+        today = datetime.now(pytz.UTC).date()
+        result = supabase.table("chat_sessions").select(
+            "count", count="exact"
+        ).eq("user_id", user_id).gte(
+            "created_at", today.isoformat()
+        ).execute()
+        return result.count if hasattr(result, 'count') else 0
+    except Exception as e:
+        log_to_file(f"Erreur lors du comptage des conversations : {str(e)}", level=logging.ERROR)
+        return 0
+
+def get_messages_count(user_id: int) -> int:
+    """Compte le nombre de messages de la journée"""
+    try:
+        today = datetime.now(pytz.UTC).date()
+
+        # Récupérer les sessions actives de l'utilisateur aujourd'hui
+        sessions = supabase.table("chat_sessions").select("session_id").eq(
+            "user_id", user_id
+        ).gte("created_at", today.isoformat()).execute()
+
+        sessions = supabase.table("chat_sessions").select("session_id").eq(
+            "user_id", user_id
+        ).gte("created_at", today.isoformat()).execute()
+        
+        if not sessions.data:
+            return 0
+            
+        # Récupérer les IDs des sessions
+        session_ids = [session['session_id'] for session in sessions.data]
+        
+        # Compter les messages dans ces sessions
+        result = supabase.table("messages").select(
+            "count", count="exact"
+        ).in_("session_id", session_ids).eq(
+            "role", "user"  # Pour ne compter que les messages de l'utilisateur
+        ).execute()
+        
+        return result.count if hasattr(result, 'count') else 0
+    except Exception as e:
+        log_to_file(f"Erreur lors du comptage des messages : {str(e)}", level=logging.ERROR)
+        return 0
+    
+
+# Fin de l'implémentation des focntions de génération du résumé quatidien pour envoyer une notification à l'utilisateur ayant activé cette notif
+# ===============================================================================
+
+
+
+
+# ===============================================================================
+# Début de la section: Gestion des du cach et des erreurs
+
+
+#implémenter une gestion des erreurs et des exceptions plus robuste
+def global_exception_handler(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            error_message = f"Une erreur s'est produite : {str(e)}"
+            st.error(error_message)
+            log_to_file(f"Erreur non gérée : {error_message}\n{traceback.format_exc()}", level=logging.ERROR)
+            # Vous pouvez ajouter ici une logique pour notifier les administrateurs
+    return wrapper
+
+
+@global_exception_handler #décorateur @global_exception_handler pour la fonction plus haut def global_exeption_hundler (func)
+def handle_error(error_message):
+    st.error(f"Une erreur s'est produite : {error_message}")
+    log_to_file(f"Erreur : {error_message}", level=logging.ERROR)
+
+# Structure pour stocker le cache
+cache_store = {}
+@global_exception_handler
+def timed_cache(expires_after=timedelta(minutes=30)):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # Créer une clé unique pour cette requête
+            cache_key = f"{func.__name__}:{str(args)}:{str(kwargs)}"
+            
+            # Vérifier si nous avons une réponse en cache et si elle est encore valide
+            if cache_key in cache_store:
+                result, timestamp = cache_store[cache_key]
+                if datetime.now() - timestamp < expires_after:
+                    st.info("Réponse récupérée du cache")
+                    return result
+            
+            # Si pas de cache ou cache expiré, exécuter la fonction
+            result = func(*args, **kwargs)
+            
+            # Stocker le résultat dans le cache
+            cache_store[cache_key] = (result, datetime.now())
+            
+            return result
+        return wrapper
+    return decorator
+
+
+@lru_cache(maxsize=100)
+def expensive_operation(param):
+    """
+    Fonction simulant une opération coûteuse.
+    """
+    # Simuler une opération coûteuse
+    time.sleep(2)
+    return param * 2
+
+
+# Fin de la section: Gestion des du cach et des erreurs
+# ===============================================================================
+
+
+
+
+
+
+
+
+# ================================================================================
+# Début de la section: Authentification (login, logout)
+
+
+# Regroupe les fonctions par rôle spécifique dans le processus d'authentification.
+
+# Suit un ordre logique :
+# - Interface utilisateur
+# - Gestion des données d'authentification
+# - Vérification des informations d'authentification
+# - Initialisation de la session utilisateur
+
+# Facilite la compréhension du flux d'authentification.
+
+@timed_cache()
+async def initialize_app():
+    """Initialise l'application et gère le cache Redis"""
+    try:
+        log_to_file("Démarrage de l'application - Vérification du cache", level=logging.INFO)
+        
+        if not await auth_cache.is_cache_initialized():
+            # Premier chargement du cache
+            log_to_file("Cache vide - Chargement initial", level=logging.INFO)
+            success = await auth_cache.load_all_users_to_cache()
+            if success:
+                await auth_cache.update_cache_version()
+                # Charger aussi les sessions
+                await auth_cache.load_user_sessions_to_cache()
+                log_to_file("Chargement initial du cache réussi", level=logging.INFO)
+            else:
+                log_to_file("Échec du chargement initial du cache", level=logging.ERROR)
+        elif await auth_cache.is_cache_outdated():
+            # Mise à jour du cache existant
+            log_to_file("Cache existant - Synchronisation des modifications", level=logging.INFO)
+            await auth_cache.sync_cache_with_db()
+            await auth_cache.load_user_sessions_to_cache()  # Recharger les sessions
+        else:
+            log_to_file("Cache à jour - Aucune action nécessaire", level=logging.INFO)
+            
+        # Debug optionnel
+        await auth_cache.debug_redis_content()
+        
+    except Exception as e:
+        log_to_file(f"Erreur lors de l'initialisation : {str(e)}", level=logging.ERROR)
+
+
+
+
+@global_exception_handler
+def authentication_page():
+    hide_pages() # cacher les pages non désirée de la sidebar dans la page d'authentification
+    st.title("Bienvenue sur votre application RAG")
+    menu = ["Se connecter", "S'inscrire"]
+    choice = st.sidebar.selectbox("Menu", menu)
+
+    if choice == "Se connecter":
+        with st.form("login_form"):
+            st.subheader("Connexion")
+            email = st.text_input("Email")
+            password = st.text_input("Mot de passe", type='password')
+            
+            # Créer deux colonnes pour les boutons
+            col1, col2 = st.columns([1, 1])
+            
+            with col1:
+                if st.form_submit_button("Connexion"):
+                    success, result = login_user(email, password)
+                    if success:
+                        st.success(result)
+                        st.rerun()
+                    else:
+                        st.error(result)
+            
+            with col2:
+                if st.form_submit_button("Mot de passe oublié ?"):
+                    st.session_state['show_reset'] = True
+
+        # Formulaire de réinitialisation du mot de passe
+        if st.session_state.get('show_reset', False):
+            with st.form("reset_form", clear_on_submit=True):
+                st.subheader("Réinitialisation du mot de passe")
+                reset_email = st.text_input("Entrez votre email")
+                if st.form_submit_button("Envoyer les instructions"):
+                    if reset_email:
+                        with st.spinner("Envoi en cours..."):
+                            success, msg = initiate_password_reset(reset_email)
+                            if success:
+                                st.success(msg)
+                                st.session_state['show_reset'] = False
+                            else:
+                                st.error(msg)
+                    else:
+                        st.error("Veuillez entrer votre email")
+
+    elif choice == "S'inscrire":
+        with st.form("signup_form"):
+            st.subheader("Inscription")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                email = st.text_input("Email")
+                password = st.text_input("Mot de passe", type='password')
+                password_confirm = st.text_input("Confirmez le mot de passe", type='password')
+            
+            with col2:
+                nom = st.text_input("Nom")
+                prenom = st.text_input("Prénom")
+                profession = st.text_input("Profession")
+                entreprise = st.text_input("Entreprise")
+
+            # Option pour créer un admin (visible uniquement pour les admins connectés)
+            create_as_admin = False
+            # Vérification sécurisée du rôle administrateur
+            is_admin = (
+                'user' in st.session_state 
+                and isinstance(st.session_state.get('user'), dict) 
+                and st.session_state['user'].get('role') == 'admin'
+            )
+            
+            if is_admin:
+                create_as_admin = st.checkbox("Créer en tant qu'administrateur")
+
+            submit_button = st.form_submit_button("Inscription")
+            
+            if submit_button:
+                if password != password_confirm:
+                    st.error("Les mots de passe ne correspondent pas.")
+                else:
+                    professional_info = {
+                        "profession": profession,
+                        "entreprise": entreprise
+                    }
+                    # Définir le rôle en fonction du choix
+                    role = 'admin' if create_as_admin and is_admin else 'user'
+                    success, result = register_user(
+                        email=email,
+                        password=password,
+                        nom=nom,
+                        prenom=prenom,
+                        professional_info=professional_info,
+                        role=role
+                    )
+                    if success:
+                        st.success(result)
+                    else:
+                        st.error(result)
+
+def check_access_validity(ip_address: str, email: str) -> Tuple[bool, str]:
+    """
+    Vérifie à la fois les restrictions d'IP et de domaine email.
+    
+    Args:
+        ip_address (str): L'adresse IP à vérifier
+        email (str): L'adresse email à vérifier
+        
+    Returns:
+        Tuple[bool, str]: Un tuple contenant:
+            - bool: True si l'accès est autorisé, False sinon
+            - str: Message d'erreur si l'accès est refusé, chaîne vide si autorisé
+    """
+    try:
+        # Récupérer toutes les restrictions actives en une seule requête
+        restrictions = supabase.table("access_restrictions").select("*").eq("is_active", True).execute()
+        
+        # Si pas de restrictions actives, autoriser l'accès
+        if not restrictions.data:
+            return True, ""
+            
+        restrictions_data = restrictions.data[0]
+        
+        # Vérifier les restrictions d'IP
+        allowed_ip_ranges = restrictions_data.get('allowed_ip_ranges', [])
+        if allowed_ip_ranges:
+            # Extraire l'adresse IP du dictionnaire
+            user_ip = ip_address.get('ip') if isinstance(ip_address, dict) else ip_address
+            if not any(user_ip == allowed_ip for allowed_ip in allowed_ip_ranges):
+                return False, "Votre adresse IP n'est pas autorisée à accéder à cette application."
+        
+        # Vérifier les restrictions de domaine email
+        allowed_domains = restrictions_data.get('allowed_email_domains', [])
+        if allowed_domains:
+            email_domain = email.split('@')[1].lower()
+            if not any(domain.lower() == email_domain for domain in allowed_domains):
+                return False, "Votre domaine d'adresse email  n'est pas autorisé à accéder à cette application."
+        
+        # Si toutes les vérifications sont passées
+        return True, ""
+        
+    except Exception as e:
+        error_msg = f"Erreur lors de la vérification des restrictions : {str(e)}"
+        log_to_file(error_msg, level=logging.ERROR)
+        return False, error_msg
+
+
+@global_exception_handler #décorateur @global_exception_handler pour la fonction plus haut def global_exeption_hundler (func)
+def register_user(email: str, password: str, nom: str, prenom: str, professional_info: Optional[Dict[str, Any]] = None, role: Optional[str] = None) -> tuple[bool, str]:
+    """
+    Enregistre un nouvel utilisateur avec vérification d'email et d'IP. 
+    Si c'est le premier utilisateur, il sera automatiquement défini comme administrateur.
+    Si c'est un utilisateur existant, il sera automatiquement défini comme utilisateur normal.
+    """
+    try:
+        ip_address = get_user_ip()
+        log_to_file(f"(def register_user)-Adresse IP de l'utilisateur : {ip_address}", level=logging.INFO) # Afficher l'adresse IP pour le debug
+    
+        # Vérifier les restrictions d'IP et d'email en une seule fois
+        is_valid, error_message = check_access_validity(ip_address, email)
+        if not is_valid:
+            return False, error_message
+        
+
+        # Vérifier si c'est le premier utilisateur (sera admin par défaut)
+        users_count = supabase.table("users").select("count", count="exact").execute()
+        is_first_user = users_count.count == 0 if hasattr(users_count, 'count') else True
+        
+        # Vérifier si l'email existe déjà
+        existing_user = supabase.table("users").select("email").eq("email", email).execute()
+        if existing_user.data:
+            return False, "Cet email est déjà utilisé."
+
+        # Hasher le mot de passe
+        hashed_password = bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+        
+        # Déterminer le rôle
+        if is_first_user:
+            assigned_role = 'admin'  # Premier utilisateur est toujours admin
+        else:
+            assigned_role = role if role in ['admin', 'user'] else 'user'
+        
+        # Préparer les données utilisateur
+        user_data = {
+            "email": email,
+            "password": hashed_password,
+            "nom": nom,
+            "prenom": prenom,
+            "role": assigned_role,
+            "is_active": False,  # L'utilisateur sera activé après vérification
+            "created_at": datetime.now(pytz.UTC).isoformat(),
+            "professional_info": professional_info or {}
+        }
+        
+        # Insérer l'utilisateur
+        data = supabase.table("users").insert(user_data).execute()
+        
+        if data.data:
+            user_id = data.data[0]['id']
+            
+            # Initialiser les permissions par défaut pour les assistants
+            default_permissions = [
+                {"user_id": user_id, "assistant_type": "insuranceSANTE", "is_authorized": False},
+                {"user_id": user_id, "assistant_type": "insuranceCAR", "is_authorized": False},
+                {"user_id": user_id, "assistant_type": "insuranceBTP", "is_authorized": False},
+                {"user_id": user_id, "assistant_type": "Pilotage", "is_authorized": False},
+                {"user_id": user_id, "assistant_type": "RH", "is_authorized": False}
+                
+                
+            ]
+            
+            # Si c'est le premier utilisateur (admin), autoriser tous les assistants
+            if is_first_user:
+                for perm in default_permissions:
+                    perm["is_authorized"] = True
+
+            # Insérer les permissions
+            supabase.table("user_assistant_permissions").insert(default_permissions).execute()
+            
+            # Initialiser les préférences de notification
+            default_notifications = {
+                "user_id": user_id,
+                "email_notifications": True,
+                "security_alerts": True,
+                "assistant_updates": True,
+                "daily_summary": True,
+                "created_at": datetime.now(pytz.UTC).isoformat(),
+                "updated_at": datetime.now(pytz.UTC).isoformat()
+            }
+            
+            # Insérer les préférences de notification
+            supabase.table("notification_preferences").insert(default_notifications).execute()
+            
+            # Créer un token de vérification
+            verification_token = secrets.token_urlsafe(32)
+            expires_at = datetime.now(pytz.UTC) + timedelta(days=7)
+            
+            # Enregistrer le token de vérification
+            supabase.table("email_verification").insert({
+                "user_id": user_id,
+                "email": email,
+                "verification_token": verification_token,
+                "expires_at": expires_at.isoformat()
+            }).execute()
+            
+            # Envoyer l'email de vérification
+            send_verification_email(email, verification_token)
+            
+            log_to_file(f"Nouvel utilisateur enregistré: {email} avec le rôle: {assigned_role}", level=logging.INFO)
+            if is_first_user:
+                return True, "Inscription réussie ! Vous êtes le premier utilisateur et avez été défini comme administrateur. Veuillez vérifier votre email pour activer votre compte."
+            return True, "Inscription réussie ! Veuillez vérifier votre email pour activer votre compte."
+            
+        return False, "Erreur lors de l'enregistrement."
+    
+    except Exception as e:
+        log_to_file(f"Erreur lors de l'inscription : {str(e)}", level=logging.ERROR)
+        return False, f"Erreur lors de l'inscription : {str(e)}"
+
+
+async def login_user_async(email: str, password: str) -> tuple[bool, str]:
+    """
+    Connecte un utilisateur de manière asynchrone avec vérification des restrictions.
+    Les utilisateurs ayant le rôle "admin" sont exemptés des restrictions.
+    
+    Args:
+        email (str): L'adresse email de l'utilisateur
+        password (str): Le mot de passe de l'utilisateur
+        
+    Returns:
+        Tuple[bool, str]: Un tuple contenant:
+            - bool: True si la connexion est réussie, False sinon
+            - str: Message d'erreur si la connexion a échoué, chaîne vide si réussie
+    """
+    try:
+        ip_address = get_user_ip()
+        
+        # Récupérer l'utilisateur
+        cached_user = await auth_cache.get_user_from_cache(email)
+        if cached_user:
+            # Utilisateur trouvé dans le cache
+            log_to_file(f"Utilisateur trouvé dans le cache: {email}", level=logging.INFO)
+            user = cached_user
+        else:
+            # Si pas dans le cache, requête Supabase
+            user_query = supabase.table("users").select("*").eq("email", email).execute()
+            if not user_query.data:
+                return False, "Utilisateur non trouvé."
+            
+            user = user_query.data[0]
+            # Mettre en cache pour les prochaines fois
+            await auth_cache.set_user_in_cache(user)
+            log_to_file(f"Utilisateur mis en cache: {email}", level=logging.INFO)
+        
+        # Vérifier le rôle de l'utilisateur
+        is_admin = user['role'] == 'admin'
+        
+        # Si l'utilisateur n'est pas admin, vérifier les restrictions d'IP et de domaine email
+        if not is_admin:
+            is_valid, error_message = check_access_validity(ip_address, email)
+            if not is_valid:
+                return False, error_message
+        
+        # Vérifier si le compte est actif
+        if not user.get('is_active', True):
+            return False, "Ce compte a été désactivé. Contactez l'administrateur."
+        
+        # Vérifier le mot de passe
+        if not bcrypt.checkpw(password.encode(), user['password'].encode()):
+            return False, "Mot de passe incorrect."
+
+        # Mettre à jour la dernière connexion
+        current_time = datetime.now(pytz.UTC).isoformat()
+        supabase.table("users").update({
+            "last_login": current_time
+        }).eq("id", user['id']).execute()
+        
+        # Mettre à jour le cache avec la nouvelle date de connexion
+        user['last_login'] = current_time
+        await auth_cache.set_user_in_cache(user)
+
+        # Générer le token JWT
+        expires_at = datetime.now(pytz.UTC) + timedelta(days=1)
+        token = jwt.encode({
+            "id": user['id'],
+            "email": email,
+            "nom": user['nom'],
+            "prenom": user['prenom'],
+            "role": user['role'],
+            "exp": expires_at.timestamp()
+        }, JWT_SECRET, algorithm="HS256")
+        
+        # Gérer la session
+        session_data = {
+            "token": token,
+            "expires_at": expires_at.isoformat()
+        }
+        
+        existing_session = supabase.table("user_sessions").select("*").eq("user_id", user['id']).execute()
+        if existing_session.data:
+            supabase.table("user_sessions").update(session_data).eq("user_id", user['id']).execute()
+        else:
+            session_data["user_id"] = user['id']
+            supabase.table("user_sessions").insert(session_data).execute()
+        
+        # Configurer la session state
+        st.session_state['user'] = jwt.decode(token, JWT_SECRET, algorithms=["HS256"])
+        st.session_state['user_theme'] = load_theme_preference()
+        st.session_state['authentication_status'] = True
+        st.session_state['user_id'] = user['id']
+
+        # Envoyer la notification de connexion
+        notify_security_alert(user['id'], 
+            f"Nouvelle connexion détectée le {datetime.now(pytz.UTC).strftime('%Y-%m-%d à %H:%M')} UTC"
+        )
+        
+        log_to_file(f"Connexion réussie pour l'utilisateur: {email}")
+        return True, "Connexion réussie"
+    
+    except Exception as e:
+        log_to_file(f"Erreur lors de la connexion : {str(e)}", logging.ERROR)
+        return False, f"Erreur lors de la connexion : {str(e)}"
+
+
+def login_user(email: str, password: str) -> tuple[bool, str]:
+    """Version synchrone de login_user pour Streamlit"""
+    import asyncio
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop.run_until_complete(login_user_async(email, password))
+    except Exception as e:
+        log_to_file(f"Erreur lors de la connexion synchrone : {str(e)}", logging.ERROR)
+        return False, f"Erreur lors de la connexion : {str(e)}"
+
+
+@global_exception_handler
+async def logout():
+    try:
+        if 'user_id' in st.session_state:
+            user_id = st.session_state['user_id']
+            email = st.session_state.get('user', {}).get('email')
+            
+            # Notification de déconnexion
+            notify_security_alert(user_id, 
+                f"Déconnexion effectuée le {datetime.now(pytz.UTC).strftime('%Y-%m-%d à %H:%M')} UTC"
+            )
+            
+            # Supprimer du cache
+            if email:
+                await cache_manager.delete(f"user_email:{email}")
+            
+            # Supprimer la session utilisateur
+            supabase.table("user_sessions").delete().eq("user_id", user_id).execute()
+
+            # Désactiver les sessions de chat
+            supabase.table("chat_sessions").update({
+                "is_active": False
+            }).eq("user_id", user_id).eq("is_active", True).execute()
+
+    except Exception as e:
+        log_to_file(f"Erreur lors de la déconnexion : {str(e)}")
+    finally:
+        # Nettoyer la session state
+        keys_to_clear = [
+            'authentication_status', 
+            'user', 
+            'user_id', 
+            'user_theme', 
+            'chat_history', 
+            'current_chat_session'
+        ]
+        for key in keys_to_clear:
+            if key in st.session_state:
+                del st.session_state[key]
+    st.rerun()
+
+def sync_logout():
+    """Wrapper synchrone pour logout"""
+    import asyncio
+    asyncio.run(logout())
+
+
+
+
+@global_exception_handler
+def check_authentication():
+    """Vérifie la validité de l'authentification de l'utilisateur"""
+    try:
+        # Si l'utilisateur n'est pas dans la session, vérifier dans la base de données
+        if 'user_id' not in st.session_state:
+            # Récupérer toutes les sessions non expirées
+            current_time = datetime.now(pytz.UTC)
+            sessions = supabase.table("user_sessions").select("*").gt("expires_at", current_time.isoformat()).execute()
+            
+            if sessions.data:
+                session = sessions.data[0]  # Prendre la session la plus récente
+                try:
+                    # Vérifier si le token est valide
+                    user = jwt.decode(session['token'], JWT_SECRET, algorithms=["HS256"])
+                    # Si le token est valide, restaurer la session
+                    st.session_state['user'] = user
+                    st.session_state['user_id'] = session['user_id']
+                    st.session_state['authentication_status'] = True
+                    st.session_state['user_theme'] = load_theme_preference()
+                    
+                    # Rafraîchir le token si nécessaire
+                    expires_at = datetime.fromisoformat(session['expires_at'].replace('Z', '+00:00'))
+                    if expires_at - current_time < timedelta(hours=1):
+                        refresh_token()
+                    return True
+                except jwt.InvalidTokenError:
+                    pass
+
+            return False
+
+        # Si l'utilisateur est dans la session, vérifier si le token est toujours valide
+        user_id = st.session_state['user_id']
+        session = supabase.table("user_sessions").select("*").eq("user_id", user_id).order('created_at', desc=True).limit(1).execute()
+        
+        if session.data:
+            session = session.data[0]
+            try:
+                expires_at = datetime.fromisoformat(session['expires_at'].replace('Z', '+00:00'))
+                if expires_at > datetime.now(pytz.UTC):
+                    # Vérifier si le token est valide
+                    jwt.decode(session['token'], JWT_SECRET, algorithms=["HS256"])
+                    
+                    # Rafraîchir le token si nécessaire
+                    if expires_at - datetime.now(pytz.UTC) < timedelta(hours=1):
+                        refresh_token()
+                    return True
+            except jwt.InvalidTokenError:
+                pass
+        
+        # Si on arrive ici, la session n'est plus valide
+        sync_logout()
+        return False
+        
+    except Exception as e:
+        print(f"Erreur lors de la vérification de l'authentification : {str(e)}")
+        return False
+
+
+def send_verification_email(email: str, token: str) -> bool:
+    """Envoie l'email de vérification"""
+    try:
+        subject = "Vérification de votre compte"
+        # Utiliser directement localhost:8501 sans http://
+        base_url = "localhost:8501"
+        
+        # Construire l'URL avec le format correct pour Streamlit
+        verification_url = f"http://{base_url}/Verify_email?token={token}"
+        # Note: "Verify_email" correspond au nom de la page dans Streamlit (le nom du fichier sans .py)
+        
+        html_content = f"""
+        <html>
+            <body>
+                <h2>Vérification de votre compte</h2>
+                <p>Merci de vous être inscrit. Pour finaliser votre inscription, veuillez cliquer sur le lien ci-dessous :</p>
+                <p><a href="{verification_url}">Vérifier mon compte</a></p>
+                <p>Ce lien est valable pendant 7 jours.</p>
+                <p>Si vous n'avez pas créé de compte, veuillez ignorer cet email.</p>
+                <p>Si le lien ne fonctionne pas, copiez et collez cette URL dans votre navigateur :</p>
+                <p>{verification_url}</p>
+            </body>
+        </html>
+        """
+        log_to_file(f"URL de vérification générée : {verification_url}", level=logging.INFO)
+        return send_email(email, subject, html_content)
+    except Exception as e:
+        log_to_file(f"Erreur lors de l'envoi de l'email de vérification : {str(e)}", level=logging.ERROR)
+        return False
+
+
+
+
+
+def initialize_missing_notification_preferences():
+    """Initialise les préférences de notification pour les utilisateurs qui n'en ont pas"""
+    try:
+        # Récupérer tous les utilisateurs
+        users = supabase.table("users").select("id").execute()
+        
+        # Récupérer les utilisateurs qui ont déjà des préférences
+        existing_prefs = supabase.table("notification_preferences").select("user_id").execute()
+        existing_user_ids = [pref['user_id'] for pref in existing_prefs.data]
+        
+        # Pour chaque utilisateur sans préférences
+        for user in users.data:
+            if user['id'] not in existing_user_ids:
+                # Créer les préférences par défaut
+                default_notifications = {
+                    "user_id": user['id'],
+                    "email_notifications": True,
+                    "security_alerts": True,
+                    "assistant_updates": True,
+                    "daily_summary": True,
+                    "created_at": datetime.now(pytz.UTC).isoformat(),
+                    "updated_at": datetime.now(pytz.UTC).isoformat()
+                }
+                
+                # Insérer les préférences
+                supabase.table("notification_preferences").insert(default_notifications).execute()
+                log_to_file(f"Préférences de notification initialisées pour l'utilisateur {user['id']}", level=logging.INFO)
+                
+    except Exception as e:
+        log_to_file(f"Erreur lors de l'initialisation des préférences : {str(e)}", level=logging.ERROR)
+
+
+# Fin de la section: Authentification (login, sync_logout)
+# ===============================================================================
+
+
+
+
+# ================================================================================
+# Début de la section: Chat et Interface utilisateur
+
+
+# fonction pour initialiser le choix de l'assistant
+@global_exception_handler #décorateur @global_exception_handler pour la fonction plus haut def global_exeption_hundler (func)
+def init_session_state():
+    if 'authentication_status' not in st.session_state:
+        st.session_state['authentication_status'] = None
+    if 'user' not in st.session_state:
+        st.session_state['user'] = None
+    if 'chat_history' not in st.session_state:
+        st.session_state['chat_history'] = []
+    # Assurez-vous que current_assistant a toujours une valeur par défaut
+    if 'current_assistant' not in st.session_state:
+        st.session_state['current_assistant'] = 'insuranceSANTE'  # Valeur par défaut
+    if 'user_theme' not in st.session_state:
+        st.session_state['user_theme'] = load_theme_preference()
+    if 'sidebar_bg' not in st.session_state:
+        st.session_state.sidebar_bg = None
+    if 'sidebar_bg_color' not in st.session_state:
+        st.session_state.sidebar_bg_color = "#f0f2f6"  # Couleur par défaut
+
+
+@global_exception_handler #décorateur @global_exception_handler pour la fonction plus haut def global_exeption_hundler (func)
+async def test_flowise_connection():
+    """Test asynchrone des connexions Flowise"""
+    client = AsyncFlowiseClient()
+    try:
+        results = await client.check_health()
+        
+        for assistant_type, is_healthy in results.items():
+            if is_healthy:
+                st.success(f"Connexion réussie à l'assistant {assistant_type}!")
+            else:
+                st.error(f"La connexion a échoué pour l'assistant {assistant_type}")
+        
+        return all(results.values())
+    except Exception as e:
+        st.error(f"Erreur lors du test des connexions : {str(e)}")
+        log_to_file(f"Erreur lors du test des connexions : {str(e)}", level=logging.ERROR)
+        return False
+    finally:
+        await client.close()
+    
+
+@timed_cache(expires_after=timedelta(minutes=30))
+@global_exception_handler #décorateur @global_exception_handler pour la fonction plus haut def global_exeption_hundler (func)
+async def query_flowise(question, assistant_type, max_retries=3, timeout=60):
+    """Version asynchrone optimisée de query_flowise avec rate limiting"""
+    cancel_container = st.empty()
+    should_cancel = False
+    attempt_count = 0
+
+    def create_cancel_button():
+        nonlocal attempt_count
+        col1, col2 = cancel_container.columns([3, 1])
+        with col2:
+            if st.button("Annuler", key=f"cancel_btn_{attempt_count}"):
+                nonlocal should_cancel
+                should_cancel = True
+                log_to_file("Requête annulée par l'utilisateur")
+                return True
+        attempt_count += 1
+        return False
+
+    client = AsyncFlowiseClient()
+    status_container = None
+    
+    try:
+        user_id = str(st.session_state.get('user', {}).get('id', 'anonymous'))
+        
+        # Obtenir le compte des requêtes une seule fois au début
+        request_count = await client.rate_limiter.get_user_requests_count(user_id)
+        log_to_file(f"User ID: {user_id} - Requêtes effectuées: {request_count}", level=logging.INFO)
+
+        for attempt in range(max_retries):
+            if should_cancel:
+                if status_container:
+                    status_container.empty()
+                cancel_container.empty()
+                return {"error": "Requête annulée par l'utilisateur"}
+            
+            status_container = st.status(f"Tentative {attempt + 1}/{max_retries}...", expanded=True)
+            
+            try:
+                create_cancel_button()
+                status_container.write(f"Envoi de la requête à l'assistant (timeout: {timeout}s)")
+                
+                # Utiliser asyncio.wait_for pour gérer le timeout de manière plus efficace
+                result = await asyncio.wait_for(
+                    client.query_assistant(
+                        question=question,
+                        assistant_type=assistant_type,
+                        user_id=user_id
+                    ),
+                    timeout=timeout
+                )
+                
+                if should_cancel:
+                    return {"error": "Requête annulée par l'utilisateur"}
+                
+                if "error" in result:
+                    if "Trop de requêtes" in result["error"]:
+                        status_container.write("Limite de requêtes atteinte. Attente avant nouvelle tentative...")
+                        # Utiliser une attente exponentielle
+                        await asyncio.sleep(min(2 ** attempt, 10))
+                        continue
+                    
+                    if attempt < max_retries - 1:
+                        status_container.write("Nouvelle tentative...")
+                        continue
+                    
+                    return result
+                
+                # Succès
+                cancel_container.empty()
+                status_container.update(label="Réponse reçue !", state="complete")
+                return result
+                
+            except asyncio.TimeoutError:
+                log_to_file(f"Timeout lors de la tentative {attempt + 1}", level=logging.WARNING)
+                if attempt < max_retries - 1:
+                    st.warning(f"Tentative {attempt + 1} a expiré, nouvelle tentative...")
+                    # Utiliser une attente exponentielle
+                    await asyncio.sleep(min(2 ** attempt, 10))
+                    continue
+                return {"error": "Timeout de toutes les requêtes"}
+                
+            except Exception as e:
+                log_to_file(f"Erreur lors de la tentative {attempt + 1}: {str(e)}", level=logging.ERROR)
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(min(2 ** attempt, 10))
+                    continue
+                return {"error": str(e)}
+            
+            finally:
+                if status_container and attempt < max_retries - 1:
+                    status_container.empty()
+    
+    finally:
+        await client.close()
+        if status_container:
+            status_container.empty()
+        cancel_container.empty()
+
+
+@global_exception_handler
+def update_message_feedback(message_id, feedback):
+    """Mettre à jour le feedback d'un message"""
+    try:
+        supabase.table("messages").update(
+            {"feedback": feedback}
+        ).eq("message_id", message_id).execute()
+        return True
+    except Exception as e:
+        log_to_file(f"Erreur lors de la mise à jour du feedback : {str(e)}", level=logging.ERROR)
+        return False
+
+
+# Fonction export_conversation pour retourner les données au lieu de créer un bouton de téléchargement
+@global_exception_handler
+def export_conversation():
+    if st.session_state['chat_history']:
+        conversation_data = {
+            "user": st.session_state['user'],
+            "timestamp": datetime.now().isoformat(),
+            "messages": st.session_state['chat_history']
+        }
+        json_data = json.dumps(conversation_data, indent=2)
+        st.download_button(
+            label="Télécharger la conversation",
+            data=json_data,
+            file_name="conversation_export.json",
+            mime="application/json"
+        )
+    else:
+        st.warning("Aucune conversation à exporter.")
+
+
+@global_exception_handler
+def check_assistant_access(user_id: int, assistant_type: str) -> bool:
+    """
+    Vérifie si l'utilisateur a accès à un assistant spécifique.
+    """
+    try:
+        # Si l'utilisateur est admin, il a accès à tout
+        user = supabase.table("users").select("role").eq("id", user_id).execute()
+        if user.data and user.data[0]['role'] == 'admin':
+            return True
+            
+        # Sinon, vérifier les permissions spécifiques
+        response = supabase.table("user_assistant_permissions").select("is_authorized").eq(
+            "user_id", user_id
+        ).eq("assistant_type", assistant_type).execute()
+        
+        if response.data:
+            return response.data[0]['is_authorized']
+        return False
+    except Exception as e:
+        log_to_file(f"Erreur lors de la vérification des accès : {str(e)}", level=logging.ERROR)
+        return False
+
+
+@global_exception_handler #décorateur @global_exception_handler pour la fonction plus haut def global_exeption_hundler (func)
+def improved_ui():
+    """
+    Interface utilisateur principale avec vérification des autorisations.
+    """
+    init_session_state()
+    remove_streamlit_style()
+    hide_pages()
+    current_theme = st.session_state.user_theme
+    apply_theme(current_theme)
+    inject_custom_css(current_theme)
+    add_sidebar_logo(current_theme)
+    force_streamlit_style_update()
+    apply_chat_styles(current_theme)
+    inject_custom_toggle_css(current_theme)
+    save_theme_preference(current_theme)
+    check_and_send_daily_summary()
+    create_custom_footer()
+    asyncio.run(test_flowise_connection())
+    
+    if 'user_id' not in st.session_state:
+        st.error("Session utilisateur non valide")
+        return
+        
+    if 'current_chat_session' not in st.session_state:
+        session_id = sync_load_active_chat_session(st.session_state['user_id'])
+        if not session_id:
+            st.error("Impossible de charger la session de chat")
+            return
+    
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = sync_load_chat_history(st.session_state['current_chat_session'])
+
+    with st.sidebar:
+        st.markdown(f"### Bienvenue, {st.session_state['user']['prenom']} {st.session_state['user']['nom']}")
+        user_id = st.session_state['user']['id']
+        
+        # Section Admin - Placer ceci en premier, avant tout autre élément de la sidebar
+        if 'role' in st.session_state['user'] and st.session_state['user']['role'] == 'admin':
+            with st.container():  # Utiliser un container pour regrouper les éléments admin
+                st.write("### 🔧 Administration")
+                if st.button("Accéder au Dashboard Admin"):
+                    st.session_state['show_admin'] = True
+                    st.rerun()
+                st.write("---")  # Séparateur
+        
+        # Liste complète des assistants avec leurs détails
+        assistant_options = {
+            'insuranceSANTE': 'Colibri Vitalité ❣️',
+            'insuranceCAR': 'Colibri Carburant 🚘',
+            'insuranceBTP': 'Colibri Batisseur 🏠',
+            'Pilotage': 'Colibri Tatillon 👨🏻‍✈️',
+            'RH': 'Colibri Equipage 🪪',
+        }
+        
+        # Filtrer les assistants autorisés
+        authorized_assistants = {
+            key: value for key, value in assistant_options.items()
+            if check_assistant_access(user_id, key)
+        }
+        
+        if not authorized_assistants:
+            st.warning("Vous n'avez accès à aucun assistant pour le moment. Contactez un administrateur pour obtenir les autorisations nécessaires.")
+            return
+            
+        # Sélection de l'assistant
+        selected_assistant = st.selectbox(
+            "Choisissez votre assistant",
+            options=list(authorized_assistants.keys()),
+            format_func=lambda x: authorized_assistants[x],
+            key='assistant_selector'
+        )
+        
+        if selected_assistant != st.session_state.get('current_assistant'):
+            st.session_state.current_assistant = selected_assistant
+            st.session_state.chat_history = []
+            st.rerun()
+
+        # Menu dépliant pour les actions utilisateur
+        with st.expander("Actions utilisateur", expanded=False):
+            theme_switcher()
+            # Bouton pour accéder au profil utilisateur
+            if st.button("Mon Profil 👤"):
+               st.switch_page("pages/profile.py")
+            
+            if st.button("Vider le cache 🚮"):
+                cache_store.clear()
+                st.success("Cache vidé avec succès!")
+            
+            if st.button("Effacer l'historique 📜"):
+                st.session_state.chat_history = []
+                st.rerun()
+            
+            if st.button("Exporter la conversation 📤"):
+                export_conversation()
+
+            if st.button("Déconnexion"):
+                sync_logout()
+        
+        # Affichage des permissions actuelles
+        with st.expander("Vos accès", expanded=False):
+            st.write("#### Assistants autorisés")
+            for assistant_type, assistant_name in assistant_options.items():
+                has_access = check_assistant_access(user_id, assistant_type)
+                icon = "✅" if has_access else "❌"
+                st.write(f"{icon} {assistant_name}")
+
+    # Charger l'historique des messages
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = load_chat_history(st.session_state['current_chat_session'])
+
+    # Zone de chat principale
+    chat_container = st.container()
+    with chat_container:
+        for message in st.session_state.chat_history:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+                if message["role"] == "assistant":
+                    col1, spacer1, col2, spacer2, col4 = st.columns([1, 1, 1, 2, 16])
+                    with col1:
+                        if st.button("👍", key=f"like_{message['message_id']}"):
+                            if update_message_feedback(message['message_id'], 'positive'):
+                                message['feedback'] = 'positive'
+                                st.rerun()
+                    with col2:
+                        if st.button("👎", key=f"dislike_{message['message_id']}"):
+                            if update_message_feedback(message['message_id'], 'negative'):
+                                message['feedback'] = 'negative'
+                                st.rerun()
+                    with col4:
+                        if message.get('feedback'):
+                            st.write(f"Feedback: {'Positif' if message['feedback'] == 'positive' else 'Négatif'}")
+
+    # Zone de saisie
+    user_input = st.chat_input("Posez votre question ici...")
+    if user_input:
+        # Sauvegarder et afficher le message utilisateur
+        saved_message = sync_save_message(
+            st.session_state['current_chat_session'],
+            "user",
+            user_input,
+            st.session_state.current_assistant
+        )
+        if saved_message:
+            st.session_state.chat_history.append({
+                "role": "user",
+                "content": user_input,
+                "message_id": saved_message["message_id"],
+                "assistant_type": st.session_state.current_assistant
+            })
+        
+        with st.spinner("L'assistant réfléchit..."):
+                response = asyncio.run(query_flowise(
+                    question=user_input,
+                    assistant_type=st.session_state.current_assistant,
+                    max_retries=3,
+                    timeout=60
+                ))
+        
+        if 'error' in response:
+            st.error(f"Erreur: {response['error']}")
+        else:
+            # Sauvegarder et afficher la réponse de l'assistant
+            saved_message = sync_save_message(
+                st.session_state['current_chat_session'],
+                "assistant",
+                response['answer'],
+                st.session_state.current_assistant
+            )
+            if saved_message:
+                st.session_state.chat_history.append({
+                    "role": "assistant",
+                    "content": response['answer'],
+                    "message_id": saved_message["message_id"],
+                    "assistant_type": st.session_state.current_assistant
+                })
+        
+        st.rerun()
+
+    # Aide contextuelle
+    with st.expander("Aide"):
+        st.markdown("""
+        ### Comment utiliser cette application :
+        1. **Poser une question** : Tapez votre question dans la zone de texte en bas de l'écran et appuyez sur Entrée.
+        2. **Historique du chat** : Vos conversations précédentes apparaîtront au-dessus de la zone de texte.
+        3. **Feedback** : Vous pouvez donner un feedback positif (👍) ou négatif (👎) aux réponses de l'assistant.
+        4. **Actions utilisateur** : Utilisez le menu dépliant dans la barre latérale pour diverses actions comme la déconnexion ou l'exportation de la conversation.
+        5. **Personnalisation** : Vous pouvez changer le thème de l'application dans la barre latérale.
+
+        Si vous avez d'autres questions, n'hésitez pas à demander à l'assistant !
+        """)
+
+
+# Fin de la section: Chat et Interface utilisateur
+# ================================================================================
+
+
+
+
+
+
+# ===============================================================================
+# Début de la section: Gestion des sessions  
+
+
+#générer des tokens uniques pour les sessions de chat dans Supabase
+@global_exception_handler
+def generate_chat_session_token():
+    """Générer un nouveau token UUID pour la session de chat"""
+    return str(uuid.uuid4())
+
+
+#Gère le rafraîchissement des tokens JWT dans Supabase,  utilisée pour maintenir la session active
+@global_exception_handler
+def refresh_token():
+    if 'user_id' not in st.session_state:
+        return
+
+    user_id = st.session_state['user_id']
+    try:
+        new_expires_at = datetime.now(pytz.UTC) + timedelta(days=1)
+        new_token = jwt.encode({
+            "id": user_id,
+            "exp": new_expires_at.timestamp()
+        }, JWT_SECRET, algorithm="HS256")
+        
+        supabase.table("user_sessions").update({
+            "token": new_token,
+            "expires_at": new_expires_at.isoformat()
+        }).eq("user_id", user_id).execute()
+        
+        st.session_state['user'] = jwt.decode(new_token, JWT_SECRET, algorithms=["HS256"])
+        log_to_file("Token rafraîchi avec succès", level=logging.INFO)
+    except Exception as e:
+        log_to_file(f"Erreur lors du rafraîchissement du token : {str(e)}", level=logging.ERROR)
+
+
+@global_exception_handler
+async def create_chat_session(user_id: int) -> Optional[str]:
+    """Crée une nouvelle session de chat"""
+    try:
+        # Désactiver les sessions existantes
+        supabase.table("chat_sessions").update({
+            "is_active": False
+        }).eq("user_id", user_id).eq("is_active", True).execute()
+
+        # Créer une nouvelle session
+        new_token = str(uuid.uuid4())
+        current_time = datetime.now(pytz.UTC).isoformat()
+        
+        session_data = {
+            "user_id": user_id,
+            "is_active": True,
+            "session_token": new_token,
+            "last_accessed": current_time
+        }
+        
+        response = supabase.table("chat_sessions").insert(session_data).execute()
+
+        if response.data:
+            session_id = response.data[0]['session_id']
+            session_data['session_id'] = session_id
+            
+            # Mettre à jour le cache
+            await auth_cache.update_session_and_history(session_data)
+            
+            # Mettre à jour la session state
+            st.session_state['current_chat_session'] = session_id
+            st.session_state['chat_history'] = []
+
+            log_to_file(f"Nouvelle session créée : {session_id}", level=logging.INFO)
+            return session_id
+
+        return None
+    except Exception as e:
+        log_to_file(f"Erreur lors de la création de la session : {str(e)}", level=logging.ERROR)
+        return None
+
+    
+@global_exception_handler
+async def get_active_chat_session(user_id: int) -> Optional[str]:
+    """Récupère la session de chat active depuis le cache"""
+    try:
+        session = await auth_cache.get_active_session(user_id)
+        if session:
+            st.session_state['current_chat_session'] = session['session_id']
+            return session['session_id']
+        return await create_chat_session(user_id)
+    except Exception as e:
+        log_to_file(f"Erreur lors de la récupération de la session de chat : {str(e)}", level=logging.ERROR)
+        return None
+    
+
+@global_exception_handler
+async def save_message(session_id: str, role: str, content: str, assistant_type: Optional[str] = None) -> Optional[Dict]:
+    """Sauvegarde un message et met à jour le cache"""
+    try:
+        data = {
+            "session_id": session_id,
+            "role": role,
+            "content": content,
+            "assistant_type": assistant_type,
+            "created_at": datetime.now(pytz.UTC).isoformat()
+        }
+        
+        response = supabase.table("messages").insert(data).execute()
+        
+        if response.data:
+            message_data = response.data[0]
+            
+            # Récupérer la session pour la mise à jour du cache
+            session = await auth_cache.get_active_session(st.session_state['user_id'])
+            if session:
+                await auth_cache.update_session_and_history(session, message_data)
+            
+            return message_data
+        return None
+    except Exception as e:
+        log_to_file(f"Erreur lors de la sauvegarde du message : {str(e)}", level=logging.ERROR)
+        return None
+
+def sync_save_message(session_id: str, role: str, content: str, assistant_type: Optional[str] = None) -> Optional[Dict]:
+    """Version synchrone de save_message"""
+    return asyncio.run(save_message(session_id, role, content, assistant_type))
+
+async def load_chat_history(session_id: str) -> List[Dict]:
+    """Charge l'historique des messages depuis le cache Redis"""
+    try:
+        history = await auth_cache.get_chat_history(session_id)
+        log_to_file(f"Historique chargé depuis le cache pour la session {session_id}", level=logging.INFO)
+        return history
+    except Exception as e:
+        log_to_file(f"Erreur lors du chargement de l'historique : {str(e)}", level=logging.ERROR)
+        return []
+
+def sync_load_chat_history(session_id: str) -> List[Dict]:
+    """Version synchrone de load_chat_history"""
+    return asyncio.run(load_chat_history(session_id))
+
+def verify_session_integrity():
+    """Vérifier l'intégrité des données de session"""
+    required_keys = ['current_chat_session', 'chat_session_token', 'chat_history']
+    missing_keys = [key for key in required_keys if key not in st.session_state]
+    
+    if missing_keys:
+        log_to_file(f"Données de session manquantes : {missing_keys}", level=logging.WARNING)
+        if 'user_id' in st.session_state:
+            load_active_chat_session(st.session_state['user_id'])
+        return False
+    return True
+
+
+async def load_active_chat_session(user_id: int) -> Optional[str]:
+    """Charge la session de chat active depuis le cache"""
+    try:
+        session = await auth_cache.get_active_session(user_id)
+        
+        if session:
+            session_id = session['session_id']
+            st.session_state['current_chat_session'] = session_id
+            
+            # Charger l'historique
+            messages = await load_chat_history(session_id)
+            st.session_state['chat_history'] = messages
+            
+            log_to_file(f"Session active chargée : {session_id}", level=logging.INFO)
+            return session_id
+            
+        return await create_chat_session(user_id)
+        
+    except Exception as e:
+        log_to_file(f"Erreur lors du chargement de la session : {str(e)}", level=logging.ERROR)
+        return None
+
+def sync_load_active_chat_session(user_id: int) -> Optional[str]:
+    """Version synchrone de load_active_chat_session"""
+    return asyncio.run(load_active_chat_session(user_id))
+
+# Fin de la section: Gestion des sessions
+# ===============================================================================
+ 
+
+
+
+
+# ===============================================================================
+# Début de la section principale (main)
+
+
+@global_exception_handler #décorateur @global_exception_handler pour la fonction plus haut def global_exeption_hundler (func)   
+def main():
+    asyncio.run(initialize_app())
+    init_session_state()
+    initialize_missing_notification_preferences() #initialiser les préférences de notifications manquantes 
+    hide_pages()
+        
+    if 'authentication_status' not in st.session_state:
+        st.session_state['authentication_status'] = None
+    
+    if st.session_state['authentication_status'] is not True:
+        authentication_page()
+    else:
+        is_session_valid = check_authentication()
+        
+        if is_session_valid:
+            apply_theme(st.session_state['user_theme'])
+            
+            # Vérifier si nous devons afficher le dashboard admin
+            if st.session_state.get('show_admin', False) and st.session_state['user']['role'] == 'admin':
+                asyncio.run(render_admin_dashboard())
+            else:
+                improved_ui()
+                
+        else:
+            st.warning("Votre session a expiré. Veuillez vous reconnecter.")
+            authentication_page()
+
+# Point d'entrée de l'application
+if __name__ == "__main__":
+    main()
+
+# Fin de la section principale (main)
+# ===============================================================================

requirements.txt

@@ -0,0 +1,16 @@
+streamlit  # Pour la dernière version
+supabase
+requests
+bcrypt
+pyjwt
+python-dotenv
+Pillow  # Pour l'utilisation de Image de PIL
+streamlit-cookies-manager
+extra-streamlit-components
+pandas
+aiohttp>=3.8.1  # implémenter les requêtes asynchrones avec asyncio
+asyncio>=3.4.3  # implémenter les requêtes asynchrones avec asyncio
+aiohttp-ratelimiter>=0.1.0 # pour implémenter le rate limiting
+pybreaker>=0.6.0 # pour l'implémentation du circuit breaker
+redis>=5.0.1 # implémentation d'un système de cache avec Redis afin d'optimiser les échanges avec la base de données
+flowise  # Client Python officiel pour Flowise