Ajoute des fichiers et sous-dossiers supplémentaires

.dockerignore

@@ -0,0 +1,5 @@
+__pycache__
+*.pyc
+.env
+venv/
+.git/

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[client]
+showSidebarNavigation = false

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+        "kodu-ai.claude-dev-experimental"
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "arena.codePrivacySettings": "Private",
+    "arena.maxOutputLines": 50
+}

admin_page.py

@@ -0,0 +1,875 @@
+import streamlit as st
+from typing import Dict, List, Optional, Tuple, Any, Callable, Awaitable
+import pandas as pd
+from datetime import datetime
+import pytz
+import re
+import json
+import asyncio
+import os
+from dotenv import load_dotenv
+from utils.admin import (
+    get_all_users,
+    toggle_user_status,
+    change_user_role,
+    get_user_stats,
+    update_user_info,
+    get_user_permissions,
+    update_user_permissions,
+    supabase
+)
+from utils.theme_utils import apply_tooltip_and_button_styles
+from utils.async_flowise import AsyncFlowiseClient
+
+class FlowiseStreamingClient:
+    def __init__(self):
+        """
+        Initialise le client de streaming pour les assistants Flowise
+        """
+        self.flowise_client = AsyncFlowiseClient()
+        self.assistant_types = list(self.flowise_client.api_urls.keys())
+
+    async def get_service_health(self) -> dict:
+        """
+        Vérifie la santé des services Flowise
+        Returns:
+        dict: Un dictionnaire avec le statut de chaque assistant
+        """
+        return await self.flowise_client.check_health()
+
+    async def stream_assistant_response(
+        self,
+        question: str,
+        assistant_type: str
+    ) -> dict:
+        """
+        Génère une réponse en streaming d'un assistant Flowise
+        Args:
+        question (str): La question à poser
+        assistant_type (str): Le type d'assistant à utiliser
+        Returns:
+        dict: Réponse finale de l'assistant
+        """
+        # Vérifier si l'assistant type est valide
+        if assistant_type not in self.assistant_types:
+            return {"error": f"Type d'assistant non valide : {assistant_type}"}
+        full_response = ""
+        error = None
+        try:
+            response_stream = self.flowise_client.query_assistant_stream(question, assistant_type)
+            async for chunk in response_stream:
+                try:
+                    chunk_data = json.loads(chunk)
+                    if 'error' in chunk_data:
+                        error = chunk_data['error']
+                        break
+                    if 'data' in chunk_data:
+                        # Extraire la partie de la réponse qui est nouvelle
+                        new_part = chunk_data['data'][len(full_response):]
+                        full_response = chunk_data['data']
+                        # Ajouter le nouveau morceau de réponse à l'historique du chat
+                        add_message("assistant", new_part)
+                        st.rerun() # Mettre à jour l'interface utilisateur
+                except json.JSONDecodeError:
+                    error = "Erreur de décodage du chunk de réponse"
+                    break
+        except Exception as e:
+            error = str(e)
+        # Fermer le client si nécessaire
+        await self.flowise_client.close()
+        # Retourner la réponse complète ou l'erreur
+        if error:
+            return {"error": error}
+        return {"answer": full_response}
+
+    def get_available_assistants(self) -> List[str]:
+        """
+        Récupère la liste des assistants disponibles
+        Returns:
+        List[str]: Liste des types d'assistants
+        """
+        return self.assistant_types
+
+# Fonction d'exemple pour afficher le streaming dans la console
+async def console_stream_callback(chunk: str):
+    """
+    Callback par défaut pour afficher le streaming dans la console
+    Args:
+    chunk (str): Le nouveau morceau de réponse
+    """
+    print(chunk, end='', flush=True)
+
+def render_user_permissions(user_id: int):
+    """
+    Affiche et gère les permissions d'accès aux assistants pour un utilisateur.
+    """
+    current_permissions = get_user_permissions(user_id)
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.write("##### Colibri Vitalité ❣️")
+        is_sante_authorized = current_permissions.get('insuranceSANTE', False)
+        new_sante_state = st.toggle(
+            "Autoriser l'accès",
+            value=is_sante_authorized,
+            key=f"perm_{user_id}_sante"
+        )
+        if new_sante_state != is_sante_authorized:
+            success, msg = update_user_permissions(user_id, 'insuranceSANTE', new_sante_state)
+            if success:
+                st.success("✅ Accès mis à jour")
+            else:
+                st.error(f"❌ Erreur: {msg}")
+
+        st.write("##### Colibri Carburant 🚘")
+        is_car_authorized = current_permissions.get('insuranceCAR', False)
+        new_car_state = st.toggle(
+            "Autoriser l'accès",
+            value=is_car_authorized,
+            key=f"perm_{user_id}_car"
+        )
+        if new_car_state != is_car_authorized:
+            success, msg = update_user_permissions(user_id, 'insuranceCAR', new_car_state)
+            if success:
+                st.success("✅ Accès mis à jour")
+            else:
+                st.error(f"❌ Erreur: {msg}")
+
+        st.write("##### Colibri Batisseur 🏠")
+        is_btp_authorized = current_permissions.get('insuranceBTP', False)
+        new_btp_state = st.toggle(
+            "Autoriser l'accès",
+            value=is_btp_authorized,
+            key=f"perm_{user_id}_btp"
+        )
+        if new_btp_state != is_btp_authorized:
+            success, msg = update_user_permissions(user_id, 'insuranceBTP', new_btp_state)
+            if success:
+                st.success("✅ Accès mis à jour")
+            else:
+                st.error(f"❌ Erreur: {msg}")
+
+    with col2:
+        st.write("##### Colibri Equipage 🪪")
+        is_RH_authorized = current_permissions.get('RH', False)
+        new_RH_state = st.toggle(
+            "Autoriser l'accès",
+            value=is_RH_authorized,
+            key=f"perm_{user_id}_RH"
+        )
+        if new_RH_state != is_RH_authorized:
+            success, msg = update_user_permissions(user_id, 'RH', new_RH_state)
+            if success:
+                st.success("✅ Accès mis à jour")
+            else:
+                st.error(f"❌ Erreur: {msg}")
+
+        st.write("##### Colibri Tatillon 👨🏻‍✈️")
+        is_Pilotage_authorized = current_permissions.get('Pilotage', False)
+        new_Pilotage_state = st.toggle(
+            "Autoriser l'accès",
+            value=is_Pilotage_authorized,
+            help="Cet assistant permet de consulter et modifier les données de la base de données. Il est réservé aux administrateurs.",
+            key=f"perm_{user_id}_Pilotage"
+        )
+        if new_Pilotage_state != is_Pilotage_authorized:
+            success, msg = update_user_permissions(user_id, 'Pilotage', new_Pilotage_state)
+            if success:
+                st.success("✅ Accès mis à jour")
+            else:
+                st.error(f"❌ Erreur: {msg}")
+
+def init_chat_history():
+    """Initialise l'historique du chat s'il n'existe pas"""
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+    if "is_processing" not in st.session_state:
+        st.session_state.is_processing = False
+    if "message_feedback" not in st.session_state:
+        st.session_state.message_feedback = {}
+
+def clean_message_content(content: str) -> str:
+    """Nettoie le contenu du message des métadonnées JSON"""
+    try:
+        # Si le contenu est au format JSON
+        if content.strip().startswith('{'):
+            data = json.loads(content)
+            # Si c'est un message utilisateur, extraire la requête
+            if 'next_inputs' in data and 'query' in data['next_inputs']:
+                return data['next_inputs']['query']
+            # Si c'est une réponse de l'assistant
+            if 'data' in data:
+                return data['data']
+        return content
+    except:
+        return content
+
+def add_message(role: str, content: str):
+    """Ajoute un message à l'historique du chat"""
+    message_id = str(len(st.session_state.chat_history))
+    cleaned_content = clean_message_content(content)
+    st.session_state.chat_history.append({
+        "role": role,
+        "content": cleaned_content,
+        "message_id": message_id
+    })
+
+def update_message_feedback(message_id: str, feedback: str):
+    """Met à jour le feedback d'un message"""
+    st.session_state.message_feedback[message_id] = feedback
+
+def display_chat():
+    """Affiche l'historique du chat avec un style cohérent"""
+    for message in st.session_state.chat_history:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+            if message["role"] == "assistant":
+                message_id = message.get("message_id", "")
+                col1, col2, col3 = st.columns([1, 1, 10])
+
+                with col1:
+                    if st.button("👍", key=f"like_{message_id}"):
+                        update_message_feedback(message_id, "positive")
+                        st.rerun()
+
+                with col2:
+                    if st.button("👎", key=f"dislike_{message_id}"):
+                        update_message_feedback(message_id, "negative")
+                        st.rerun()
+
+                with col3:
+                    if message_id in st.session_state.message_feedback:
+                        feedback = st.session_state.message_feedback[message_id]
+                        st.write(f"Feedback: {'Positif' if feedback == 'positive' else 'Négatif'}")
+
+async def render_admin_dashboard():
+    """Affiche le tableau de bord administrateur"""
+    if 'user' not in st.session_state or st.session_state['user'].get('role') != 'admin':
+        st.error("Accès non autorisé. Cette page est réservée aux administrateurs.")
+        return
+
+    current_theme = st.session_state.get('user_theme', 'Clair')
+    apply_tooltip_and_button_styles(current_theme)
+
+    if st.button("← Retour à l'interface principale"):
+        st.session_state['show_admin'] = False
+        st.rerun()
+
+    st.title("Dashboard Administrateur")
+
+    # Création des onglets avec le nouvel onglet de streaming
+    tab_users, tab_restrictions, tab_chatbot, tab_chatreact, testfooter, = st.tabs([
+        "👥 Gestion Utilisateurs",
+        "🔒 Restrictions d'accès",
+        "💬 Chatbot",
+        "📡 Chat React",
+        " 🧪 Test Footer"
+    ])
+
+    # Onglet Gestion Utilisateurs
+    with tab_users:
+        stats = get_user_stats()
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Total Utilisateurs", stats["total_users"])
+        with col2:
+            st.metric("Utilisateurs Actifs", stats["active_users"])
+        with col3:
+            st.metric("Administrateurs", stats["admin_users"])
+
+        st.subheader("Gestion des Utilisateurs")
+        search_term = st.text_input("Rechercher un utilisateur par email ou nom:", "")
+        users = get_all_users()
+        if users:
+            df = pd.DataFrame(users)
+            if 'created_at' in df.columns:
+                df['created_at'] = pd.to_datetime(df['created_at']).dt.strftime('%Y-%m-%d %H:%M')
+            if 'last_login' in df.columns:
+                df['last_login'] = pd.to_datetime(df['last_login']).dt.strftime('%Y-%m-%d %H:%M')
+            display_columns = ['id', 'email', 'nom', 'prenom', 'role', 'is_active', 'created_at', 'last_login']
+
+            if search_term:
+                df = df[
+                    df['email'].str.contains(search_term, case=False) |
+                    df['nom'].str.contains(search_term, case=False) |
+                    df['prenom'].str.contains(search_term, case=False)
+                ]
+
+            st.dataframe(df[display_columns], use_container_width=True)
+
+            selected_user_email = st.selectbox(
+                "Sélectionner un utilisateur",
+                options=df['email'].tolist()
+            )
+
+            if selected_user_email:
+                selected_user = df[df['email'] == selected_user_email].iloc[0]
+                user_id = selected_user['id']
+
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    with st.expander("Paramètres du compte", expanded=True):
+                        new_status = st.toggle(
+                            "Compte actif",
+                            value=selected_user['is_active'],
+                            key=f"toggle_{user_id}"
+                        )
+                        if new_status != selected_user['is_active']:
+                            success, msg = toggle_user_status(user_id, new_status)
+                            if success:
+                                st.success(msg)
+                            else:
+                                st.error(msg)
+
+                        new_role = st.selectbox(
+                            "Rôle utilisateur",
+                            options=['user', 'admin'],
+                            index=0 if selected_user['role'] == 'user' else 1,
+                            key=f"role_{user_id}"
+                        )
+                        if new_role != selected_user['role']:
+                            success, msg = change_user_role(user_id, new_role)
+                            if success:
+                                st.success(msg)
+                            else:
+                                st.error(msg)
+
+                    with st.expander("Informations détaillées", expanded=False):
+                        col3, col4 = st.columns(2)
+                        with col3:
+                            new_nom = st.text_input(
+                                "Nom",
+                                value=selected_user['nom'],
+                                key=f"nom_{user_id}"
+                            )
+                            new_email = st.text_input(
+                                "Email",
+                                value=selected_user['email'],
+                                key=f"email_{user_id}"
+                            )
+                            st.text_input(
+                                "Date de création",
+                                value=selected_user['created_at'],
+                                disabled=True
+                            )
+                        with col4:
+                            new_prenom = st.text_input(
+                                "Prénom",
+                                value=selected_user['prenom'],
+                                key=f"prenom_{user_id}"
+                            )
+                            st.text_input(
+                                "Rôle",
+                                value=selected_user['role'],
+                                disabled=True
+                            )
+                            st.text_input(
+                                "Dernière connexion",
+                                value=selected_user.get('last_login', 'Jamais'),
+                                disabled=True
+                            )
+
+                        st.write("##### Informations professionnelles")
+                        professional_info = selected_user.get('professional_info', {})
+                        if isinstance(professional_info, str):
+                            try:
+                                professional_info = json.loads(professional_info)
+                            except:
+                                professional_info = {}
+
+                        col5, col6 = st.columns(2)
+                        with col5:
+                            new_profession = st.text_input(
+                                "Profession",
+                                value=professional_info.get('profession', ''),
+                                key=f"prof_{user_id}"
+                            )
+                        with col6:
+                            new_entreprise = st.text_input(
+                                "Entreprise",
+                                value=professional_info.get('entreprise', ''),
+                                key=f"entr_{user_id}"
+                            )
+
+                        if st.button("Mettre à jour les informations", key=f"update_{user_id}"):
+                            if not re.match(r"[^@]+@[^@]+\.[^@]+", new_email):
+                                st.error("Format d'email invalide")
+                                return
+
+                            if new_email != selected_user['email']:
+                                existing_email = supabase.table("users").select("id").eq("email", new_email).neq("id", user_id).execute()
+                                if existing_email.data:
+                                    st.error("Cet email est déjà utilisé par un autre utilisateur")
+                                    return
+
+                            updated_info = {
+                                "nom": new_nom,
+                                "prenom": new_prenom,
+                                "email": new_email,
+                                "professional_info": {
+                                    "profession": new_profession,
+                                    "entreprise": new_entreprise
+                                }
+                            }
+
+                            success, msg = update_user_info(user_id, updated_info)
+                            if success:
+                                st.success("Informations mises à jour avec succès")
+                                st.rerun()
+                            else:
+                                st.error(f"Erreur lors de la mise à jour : {msg}")
+
+                with col2:
+                    with st.expander("Gestion des accès aux assistants", expanded=False):
+                        render_user_permissions(user_id)
+
+        else:
+            st.warning("Aucun utilisateur trouvé.")
+
+    # Onglet Restrictions d'accès
+    with tab_restrictions:
+        st.header("Restrictions d'accès")
+
+        current_restrictions = supabase.table("access_restrictions").select("*").eq("is_active", True).execute()
+        restrictions = current_restrictions.data[0] if current_restrictions.data else {}
+
+        with st.form("access_restrictions_form"):
+            st.subheader("🌐 Domaines email autorisés")
+            st.info("Définissez les domaines email autorisés pour l'inscription. Un domaine par ligne.")
+            domains_text = st.text_area(
+                "Domaines autorisés",
+                value="\n".join(restrictions.get('allowed_email_domains', [])),
+                help="Exemple: entreprise.com \nautreentreprise.fr",
+                placeholder="Entrez les domaines (un par ligne)"
+            )
+
+            st.subheader("🌐 Adresses IP autorisées")
+            st.info("Définissez les adresses IP autorisées pour l'inscription. Une adresse par ligne.")
+            ip_ranges_text = st.text_area(
+                "Adresses IP autorisées",
+                value="\n".join(restrictions.get('allowed_ip_ranges', [])),
+                help="Exemple: 192.168.1.1 \n10.0.0.1",
+                placeholder="Entrez les adresses IP (une par ligne)"
+            )
+
+            col1, col2, spacer1, col4 = st.columns([4,4,6,3])
+            with col1:
+                is_email_active = st.toggle(
+                    "Activer les restrictions d'email",
+                    value=restrictions.get('is_email_active', False),
+                    help="Activer/Désactiver les restrictions d'accès par email"
+                )
+
+            with col2:
+                is_ip_active = st.toggle(
+                    "Activer les restrictions d'IP",
+                    value=restrictions.get('is_ip_active', False),
+                    help="Activer/Désactiver les restrictions d'accès par IP"
+                )
+
+            with col4:
+                st.markdown("###")
+                submit_button = st.form_submit_button("💾 Enregistrer les restrictions")
+
+            if submit_button:
+                try:
+                    domains = [
+                        d.strip().lower()
+                        for d in domains_text.split('\n')
+                        if d.strip() and '.' in d.strip()
+                    ]
+
+                    ip_ranges = [
+                        ip.strip()
+                        for ip in ip_ranges_text.split('\n')
+                        if ip.strip()
+                    ]
+
+                    update_data = {
+                        "allowed_email_domains": domains,
+                        "allowed_ip_ranges": ip_ranges,
+                        "is_email_active": is_email_active,
+                        "is_ip_active": is_ip_active,
+                        "updated_at": datetime.now(pytz.UTC).isoformat()
+                    }
+
+                    if current_restrictions.data:
+                        supabase.table("access_restrictions").update(
+                            update_data
+                        ).eq("id", current_restrictions.data[0]['id']).execute()
+                    else:
+                        supabase.table("access_restrictions").insert(update_data).execute()
+
+                    st.success("✅ Restrictions mises à jour avec succès!")
+
+                    if is_email_active and domains:
+                        st.info(f"Domaines autorisés : {', '.join(domains)}")
+                    elif is_email_active and not domains:
+                        st.warning("⚠️ Aucun domaine spécifié - l'inscription sera bloquée pour tous les domaines")
+                    else:
+                        st.info("ℹ️ Les restrictions d'email sont désactivées - tous les domaines sont autorisés")
+
+                    if is_ip_active and ip_ranges:
+                        st.info(f"Adresses IP autorisées : {', '.join(ip_ranges)}")
+                    elif is_ip_active and not ip_ranges:
+                        st.warning("⚠️ Aucune adresse IP spécifiée - l'inscription sera bloquée pour toutes les adresses IP")
+                    else:
+                        st.info("ℹ️ Les restrictions d'IP sont désactivées - toutes les adresses IP sont autorisées")
+
+                except Exception as e:
+                    st.error(f"❌ Erreur lors de la mise à jour des restrictions : {str(e)}")
+
+        if restrictions.get('is_email_active') or restrictions.get('is_ip_active'):
+            st.subheader("📊 Statistiques des restrictions")
+            try:
+                users = supabase.table("users").select("email").execute()
+                if users.data:
+                    domains_count = {}
+                    for user in users.data:
+                        domain = user['email'].split('@')[1].lower()
+                        domains_count[domain] = domains_count.get(domain, 0) + 1
+
+                    st.markdown("##### Répartition des utilisateurs par domaine")
+                    for domain, count in domains_count.items():
+                        status = "✅" if not restrictions.get('allowed_email_domains') or domain in restrictions.get('allowed_email_domains', []) else "❌"
+                        st.text(f"{status} {domain}: {count} utilisateur(s)")
+            except Exception as e:
+                st.error(f"Erreur lors du calcul des statistiques : {str(e)}")
+
+
+    with tab_chatbot:
+        st.subheader("💬 Chatbot")
+        
+        def add_flowise_chat():
+            assistant_type = st.selectbox(
+                "Sélectionner l'assistant",
+                options=['SANTE', 'CAR', 'BTP', 'RH', 'PILOTAGE'],
+                format_func=lambda x: {
+                    'SANTE': 'Colibri Vitalité ',
+                    'CAR': 'Colibri Carburant ',
+                    'BTP': 'Colibri Batisseur ',
+                    'RH': 'Colibri Equipage ',
+                    'PILOTAGE': 'Colibri Tatillon '
+                }[x],
+                key="chatbot_assistant_select"
+            )
+            
+            # Définir le titre du chatbot en fonction de l'assistant sélectionné
+            assistant_titles = {
+                'SANTE': 'Colibri Vitalité',
+                'CAR': 'Colibri Carburant',
+                'BTP': 'Colibri Batisseur',
+                'RH': 'Colibri Equipage',
+                'PILOTAGE': 'Colibri Tatillon'
+            }
+            chatbot_title = assistant_titles.get(assistant_type, 'Flowise Bot')
+            
+            # Récupérer l'URL complète de l'API depuis la variable d'environnement
+            api_url_var = f"FLOWISE_API_URL_{assistant_type}"
+            api_url = os.getenv(api_url_var)
+            if not api_url:
+                st.error(f"URL de l'API non trouvée pour l'assistant {assistant_type}")
+                return
+            
+            # Extraction de l'URL de base et du chatflowid
+            apiHost = '/'.join(api_url.split('/')[:3])  # Supprimer /prediction/ID
+            # Remplacer "flowise" par "localhost" dans apiHost
+            apiHost = apiHost.replace("flowise", "localhost")
+            chatflowid = api_url.split('/')[-1]  # Récupérer l'ID
+            
+            # Configuration du chatbot en HTML
+            st.components.v1.html(f'''
+            <script type="module">
+                import Chatbot from 'https://cdn.jsdelivr.net/npm/flowise-embed/dist/web.js';
+                Chatbot.init({{
+                    chatflowid: '{chatflowid}',
+                    apiHost: '{apiHost}',
+                    chatflowConfig: {{
+                        // topK: 2
+                    }},
+                    observersConfig: {{
+                        // (optional) Allows you to execute code in parent based upon signal observations within the chatbot.
+                        // The userinput field submitted to bot ("" when reset by bot)
+                        observeUserInput: (userInput) => {{
+                            console.log({{ userInput }});
+                        }},
+                        // The bot message stack has changed
+                        observeMessages: (messages) => {{
+                            console.log({{ messages }});
+                        }},
+                        // The bot loading signal changed
+                        observeLoading: (loading) => {{
+                            console.log({{ loading }});
+                        }},
+                    }},
+                    theme: {{
+                        button: {{
+                            backgroundColor: '#3B81F6',
+                            right: 20,
+                            bottom: 20,
+                            size: 48,
+                            // small | medium | large | number
+                            dragAndDrop: true,
+                            iconColor: 'white',
+                            customIconSrc: 'https://raw.githubusercontent.com/walkxcode/dashboard-icons/main/svg/google-messages.svg',
+                            autoWindowOpen: {{
+                                autoOpen: true,
+                                //parameter to control automatic window opening
+                                openDelay: 2,
+                                // Optional parameter for delay time in seconds
+                                autoOpenOnMobile: false,
+                                //parameter to control automatic window opening in mobile
+                            }},
+                        }},
+                        tooltip: {{
+                            showTooltip: true,
+                            tooltipMessage: 'Bonjour !',
+                            tooltipBackgroundColor: 'black',
+                            tooltipTextColor: 'white',
+                            tooltipFontSize: 16,
+                        }},
+                        disclaimer: {{
+                            title: 'Avertissement',
+                            message: 'By using this chatbot, you agree to the <a target="_blank" href="https://ecg-pereire-assurances.com/mentions-legales/">Terms & Condition</a>',
+                        }},
+                        chatWindow: {{
+                            showTitle: true,
+                            showAgentMessages: true,
+                            title: '{chatbot_title}',
+                            titleAvatarSrc: 'https://raw.githubusercontent.com/walkxcode/dashboard-icons/main/svg/google-messages.svg',
+                            welcomeMessage: 'Hello! This is custom welcome message',
+                            errorMessage: 'This is a custom error message',
+                            backgroundColor: '#ffffff',
+                            backgroundImage: 'enter image path or link',
+                            // If set, this will overlap the background color of the chat window.
+                            height: 700,
+                            width: 400,
+                            fontSize: 16,
+                            starterPrompts: ['What is a bot?', 'Who are you?'],
+                            // It overrides the starter prompts set by the chat flow passed
+                            starterPromptFontSize: 15,
+                            clearChatOnReload: false,
+                            // If set to true, the chat will be cleared when the page reloads
+                            sourceDocsTitle: 'Sources:',
+                            renderHTML: true,
+                            botMessage: {{
+                                backgroundColor: '#f7f8ff',
+                                textColor: '#303235',
+                                showAvatar: true,
+                                avatarSrc: 'https://raw.githubusercontent.com/zahidkhawaja/langchain-chat-nextjs/main/public/parroticon.png',
+                            }},
+                            userMessage: {{
+                                backgroundColor: '#3B81F6',
+                                textColor: '#ffffff',
+                                showAvatar: true,
+                                avatarSrc: 'https://raw.githubusercontent.com/zahidkhawaja/langchain-chat-nextjs/main/public/usericon.png',
+                            }},
+                            textInput: {{
+                                placeholder: 'Type your question',
+                                backgroundColor: '#ffffff',
+                                textColor: '#303235',
+                                sendButtonColor: '#3B81F6',
+                                //maxChars: 50,
+                                maxCharsWarningMessage: 'You exceeded the characters limit. Please input less than 50 characters.',
+                                autoFocus: true,
+                                // If not used, autofocus is disabled on mobile and enabled on desktop. true enables it on both, false disables it on both.
+                                sendMessageSound: true,
+                                // sendSoundLocation: "send_message.mp3",
+                                // If this is not used, the default sound effect will be played if sendSoundMessage is true.
+                                receiveMessageSound: true,
+                                // receiveSoundLocation: "receive_message.mp3",
+                                // If this is not used, the default sound effect will be played if receiveSoundMessage is true.
+                            }},
+                            feedback: {{
+                                color: '#303235',
+                            }},
+                            dateTimeToggle: {{
+                                date: true,
+                                time: true,
+                            }},
+                            footer: {{
+                                textColor: '#303235',
+                                text: 'Powered by',
+                                company: 'Colibri',
+                                companyLink: 'https://ecg-pereire-assurances.com',
+                            }},
+                        }},
+                    }},
+                }});
+            </script>
+            ''', height=800)
+        add_flowise_chat()
+            
+
+    with tab_chatreact:
+        def add_flowise_chatreact():
+            assistant_type = st.selectbox(
+                "Sélectionner l'assistant",
+                options=['SANTE', 'CAR', 'BTP', 'RH', 'PILOTAGE'],
+                format_func=lambda x: {
+                    'SANTE': 'Colibri Vitalité ❣️',
+                    'CAR': 'Colibri Carburant 🚘',
+                    'BTP': 'Colibri Batisseur 🏠',
+                    'RH': 'Colibri Equipage 🪪',
+                    'PILOTAGE': 'Colibri Tatillon 👨🏻‍✈️'
+                }[x],
+                key="chatbot_full_assistant_select"
+            )
+            # Définir le titre du chatbot en fonction de l'assistant sélectionné
+            assistant_titles = {
+                'SANTE': 'Colibri Vitalité',
+                'CAR': 'Colibri Carburant',
+                'BTP': 'Colibri Batisseur',
+                'RH': 'Colibri Equipage',
+                'PILOTAGE': 'Colibri Tatillon'
+            }
+            chatbot_title = assistant_titles.get(assistant_type, 'Flowise Bot')
+            # Récupérer l'URL complète de l'API depuis la variable d'environnement
+            api_url_var = f"FLOWISE_API_URL_{assistant_type}"
+            api_url = os.getenv(api_url_var)
+            if not api_url:
+                st.error(f"URL de l'API non trouvée pour l'assistant {assistant_type}")
+                return
+            # Extraction de l'URL de base et du chatflowid
+            apiHost = '/'.join(api_url.split('/')[:3])  # Supprimer /prediction/ID
+            # Remplacer "flowise" par "localhost" dans apiHost
+            apiHost = apiHost.replace("flowise", "localhost")
+            chatflowid = api_url.split('/')[-1]  # Récupérer l'ID
+        
+            # Configuration du chatbot en HTML
+            st.components.v1.html(f'''
+            <flowise-fullchatbot></flowise-fullchatbot>
+            <body style="margin: 0">
+            <script type="module">
+                import Chatbot from "https://cdn.jsdelivr.net/npm/flowise-embed/dist/web.js";
+                Chatbot.initFull({{
+                chatflowid: "{chatflowid}",
+                apiHost: "{apiHost}",
+                theme: {{
+                    chatWindow: {{
+                        showTitle: true,
+                        title: "{chatbot_title}",
+                            titleAvatarSrc: 'https://raw.githubusercontent.com/walkxcode/dashboard-icons/main/svg/google-messages.svg',
+                        showAgentMessages: true,
+                        welcomeMessage: 'Hello! This is custom welcome message', 
+                        errorMessage: 'This is a custom error message', 
+                        backgroundColor: "#ffffff",
+                        backgroundImage: '',
+                        fontSize: 16, 
+                        starterPromptFontSize: 15, 
+                        clearChatOnReload: false, 
+                        botMessage: {{
+                            backgroundColor: "#f7f8ff",
+                            textColor: "#303235",
+                            showAvatar: true, 
+                            avatarSrc: "https://raw.githubusercontent.com/zahidkhawaja/langchain-chat-nextjs/main/public/parroticon.png",
+                        }},
+                        userMessage: {{
+                            backgroundColor: "#3B81F6",
+                            textColor: "#ffffff",
+                            showAvatar: true, 
+                            avatarSrc: "https://raw.githubusercontent.com/zahidkhawaja/langchain-chat-nextjs/main/public/usericon.png",
+                        }},
+                        textInput: {{
+                            placeholder: 'Tapez votre question ici...',
+                            backgroundColor: '#ffffff', 
+                            textColor: '#303235', 
+                            sendButtonColor: '#3B81F6', 
+                            autoFocus: true, 
+                            sendMessageSound: true, 
+                            receiveMessageSound: true, 
+                        }},
+                        feedback: {{
+                            color: '#303235', 
+                        }},
+                        footer: {{
+                            textColor: '#303235',
+                            text: 'Powered by',
+                            company: 'Colibri',
+                            companyLink: 'https://ecg-pereire-assurances.com/',
+                        }}
+                    }}
+                }}
+                }});
+            </script>
+            ''', height=800)
+        add_flowise_chatreact()
+
+
+    with testfooter:      
+        st.components.v1.html('''
+        <flowise-fullchatbot></flowise-fullchatbot>
+        <body style="margin: 0"> 
+        <script type="module"> 
+            import Chatbot from "https://cdn.jsdelivr.net/npm/flowise-embed/dist/web.js"; 
+            Chatbot.initFull({ 
+                chatflowid: "c7772c60-e798-4d02-809f-654170560e91", 
+                apiHost: "http://localhost:3000", 
+                theme: { 
+                    chatWindow: { 
+                        showTitle: true, 
+                        title: 'Flowise Bot', 
+                        titleAvatarSrc: 'https://raw.githubusercontent.com/walkxcode/dashboard-icons/main/svg/google-messages.svg', 
+                        showAgentMessages: true, 
+                        welcomeMessage: 'Hello! This is custom welcome message', 
+                        errorMessage: 'This is a custom error message', 
+                        backgroundColor: "#ffffff", 
+                        backgroundImage: '', 
+                        //height: 700, 
+                        //width: 400, 
+                        fontSize: 16, 
+                        starterPromptFontSize: 15, 
+                        clearChatOnReload: false, 
+                        botMessage: { 
+                            backgroundColor: "#f7f8ff", 
+                            textColor: "#303235", 
+                            showAvatar: true, 
+                            avatarSrc: "https://raw.githubusercontent.com/zahidkhawaja/langchain-chat-nextjs/main/public/parroticon.png", 
+                        }, 
+                        userMessage: { 
+                            backgroundColor: "#3B81F6", 
+                            textColor: "#ffffff", 
+                            showAvatar: true, 
+                            avatarSrc: "https://raw.githubusercontent.com/zahidkhawaja/langchain-chat-nextjs/main/public/usericon.png", 
+                        }, 
+                        textInput: { 
+                            placeholder: 'Tapez votre question ici...', 
+                            backgroundColor: '#ffffff', 
+                            textColor: '#303235', 
+                            sendButtonColor: '#3B81F6', 
+                            //maxChars: 50, 
+                            //maxCharsWarningMessage: 'You exceeded the characters limit. Please input less than 50 characters.', 
+                            autoFocus: true, 
+                            sendMessageSound: true, 
+                            receiveMessageSound: true, 
+                        }, 
+                        feedback: { 
+                            color: '#303235', 
+                        }, 
+                        footer: { 
+                            textColor: '#303235', 
+                            text: 'Powered by', 
+                            company: 'Clibri', 
+                            companyLink: 'https://ecg-pereire-assurances.com/', 
+                        } 
+                    } 
+                } 
+            }); 
+        </script>
+        ''', height=800)
+
+
+        
+
+
+
+
+
+
+
+
+# Exécution de la fonction principale
+if __name__ == "__main__":
+    asyncio.run(render_admin_dashboard())

docker-compose.yml

@@ -0,0 +1,119 @@
+services:
+  streamlit-app:
+    build: .
+    ports:
+      - "8501:8501"
+    environment:
+      - SUPABASE_URL=${SUPABASE_URL}
+      - SUPABASE_KEY=${SUPABASE_KEY}
+      - JWT_SECRET=${JWT_SECRET}
+      - FLOWISE_API_URL_SANTE=${FLOWISE_API_URL_SANTE}
+      - FLOWISE_API_URL_CAR=${FLOWISE_API_URL_CAR}
+      - FLOWISE_API_URL_BTP=${FLOWISE_API_URL_BTP}
+      - FLOWISE_API_URL_RH=${FLOWISE_API_URL_RH}
+      - FLOWISE_API_URL_PILOTAGE=${FLOWISE_API_URL_PILOTAGE}
+      - PYTHONUNBUFFERED=1 # Pour un meilleur logging
+      # partie concernant le reset du mot de passe
+      - EMAIL_HOST=${EMAIL_HOST}
+      - EMAIL_PORT=${EMAIL_PORT}
+      - EMAIL_HOST_USER=${EMAIL_HOST_USER}
+      - EMAIL_HOST_USER_PASSWORD=${EMAIL_HOST_USER_PASSWORD}
+      - DEFAULT_FROM_EMAIL=${DEFAULT_FROM_EMAIL}
+      - APP_URL=${APP_URL}
+      # Ajout de la configuration Redis
+      - REDIS_HOST=${REDIS_HOST}
+      - REDIS_PORT=${REDIS_PORT}
+      - QDRANT_URL=${QDRANT_URL}
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    volumes:
+      - ./app.py:/app/app.py # Pour faciliter les modifications sans rebuilds
+    depends_on:
+      - redis
+      - flowise
+      - qdrant
+    networks:
+      - redis-network
+      - flowise-network
+      - qdrant-network
+    restart: always
+
+  redis:
+    image: redis:alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    networks:
+      - redis-network
+    restart: always
+
+  redisinsight:
+    image: redislabs/redisinsight:1.14.0
+    ports:
+      - "8001:8001"
+    volumes:
+      - redisinsight_data:/db
+    depends_on:
+      - redis
+    networks:
+      - redis-network
+    restart: always
+    pull_policy: always
+
+  flowise:
+    image: flowiseai/flowise:latest
+    ports:
+      - "3000:3000"
+    environment:
+      - PORT=3000
+      # backup dans dans postrgrs supabase
+      #- DATABASE_TYPE=${DATABASE_TYPE}
+      #- DATABASE_HOST=${DATABASE_HOST}  
+      #- DATABASE_PORT=${DATABASE_PORT}              
+      #- DATABASE_NAME=${DATABASE_NAME}             
+      #- DATABASE_USER=${DATABASE_USER}   
+      #- DATABASE_PASSWORD=${DATABASE_PASSWORD}
+      #- PGSSLMODE=${PGSSLMODE}
+      # autres variables 
+      - DATABASE_PATH=/root/.flowise
+      - APIKEY_PATH=/root/.flowise
+      - SECRETKEY_PATH=/root/.flowise
+      - LOG_PATH=/root/.flowise/logs
+      - BLOB_STORAGE_PATH=/root/.flowise/storage
+      - ENCRYPTION_KEY_PATH=/root/.flowise/encryption.key
+      - FLOWISE_USERNAME=${FLOWISE_USERNAME}
+      - FLOWISE_PASSWORD=${FLOWISE_PASSWORD}
+      #- FLOWISE_AUTH_TOKEN=${FLOWISE_AUTH_TOKEN} # pas nécessaire pour l'instant
+      
+    volumes:
+      - flowise_data:/root/.flowise
+    networks:
+      - flowise-network
+    restart: always
+    pull_policy: always
+
+  qdrant:
+    image: qdrant/qdrant:latest
+    ports:
+      - "6333:6333"
+    volumes:
+      - qdrant_data:/qdrant/storage
+    networks:
+      - flowise-network
+    restart: always
+    pull_policy: always
+
+volumes:
+  redis_data:
+  redisinsight_data:
+  flowise_data:
+  qdrant_data:
+
+networks:
+  redis-network:
+    name: redis-network
+  flowise-network:
+    name: flowise-network
+  qdrant-network:
+    name: qdrant-network

pages/Verify_email.py

@@ -0,0 +1,86 @@
+import streamlit as st
+import sys
+import os
+from datetime import datetime
+import pytz
+import logging  # Ajout de l'import logging
+from utils.admin import supabase
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# IMPORTANT : set_page_config doit être la première commande Streamlit
+st.set_page_config(
+    page_title="Vérification de l'email",
+    page_icon="✉️",
+    layout="centered"
+)
+
+# Cacher les éléments de navigation
+hide_streamlit_style = """
+<style>
+    #MainMenu {visibility: hidden;}
+    header {visibility: hidden;}
+    .css-1544g2n {display: none;}
+    section[data-testid="stSidebar"] {display: none;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+
+def verify_email_token(token: str) -> tuple[bool, str]:
+    """Vérifie le token et active le compte"""
+    try:
+        # Vérifier le token
+        verification = supabase.table("email_verification").select("*").eq(
+            "verification_token", token
+        ).eq("is_verified", False).execute()
+        
+        if not verification.data:
+            return False, "Token de vérification invalide ou déjà utilisé."
+            
+        verification_data = verification.data[0]
+        expires_at = datetime.fromisoformat(verification_data['expires_at'].replace('Z', '+00:00'))
+        
+        if expires_at < datetime.now(pytz.UTC):
+            return False, "Le lien de vérification a expiré."
+            
+        # Activer l'utilisateur
+        supabase.table("users").update({
+            "is_active": True
+        }).eq("id", verification_data['user_id']).execute()
+        
+        # Marquer comme vérifié
+        supabase.table("email_verification").update({
+            "is_verified": True
+        }).eq("id", verification_data['id']).execute()
+        
+        return True, "Email vérifié avec succès!"
+        
+    except Exception as e:
+        logging.error(f"Erreur lors de la vérification : {str(e)}")
+        return False, f"Erreur lors de la vérification : {str(e)}"
+
+# Titre de la page
+st.title("✉️ Vérification de l'email")
+
+# Debug: Afficher le token reçu dans les logs
+token = st.query_params.get("token", None)
+logging.info(f"Token reçu : {token if token else 'Aucun token'}")
+
+if not token:
+    st.error("Token de vérification manquant.")
+    st.stop()
+
+# Vérifier le token et activer le compte
+success, message = verify_email_token(token)
+if success:
+    st.success(message)
+    st.info("Votre compte est maintenant actif. Vous pouvez vous connecter.")
+    
+    # Bouton pour aller à la page de connexion
+    if st.button("Aller à la page de connexion"):
+        st.switch_page("app.py")
+else:
+    st.error(message)
+    if "expiré" in message:
+        st.info("Veuillez demander un nouveau lien de vérification.")

pages/profile.py

@@ -0,0 +1,260 @@
+import streamlit as st
+from utils.admin import supabase
+import bcrypt
+from utils.notification_handler import notify_security_alert #import du module de notifications (envoie une notification de sécurité en cas de modifications des données de l"utilisateur)
+
+
+# Configuration de la page
+st.set_page_config(
+    page_title="Profil Utilisateur",
+    page_icon="👤",
+    layout="centered"
+)
+
+st.title("Mon Profil")
+
+# Vérification de l'authentification
+if 'user' not in st.session_state:
+    st.error("Vous devez être connecté pour accéder à cette page.")
+    st.stop()
+
+
+# Récupérer les informations actuelles de l'utilisateur
+user_id = st.session_state['user']['id']
+user_info = supabase.table("users").select("*").eq("id", user_id).execute()
+current_user = user_info.data[0] if user_info.data else None
+
+# Section Informations Personnelles
+st.header("📋 Informations Personnelles")
+with st.form("personal_info_form"):
+    col1, col2 = st.columns(2)
+    with col1:
+        new_nom = st.text_input("Nom", value=current_user.get('nom', ''))
+    with col2:
+        new_prenom = st.text_input("Prénom", value=current_user.get('prenom', ''))
+    
+    # Informations professionnelles
+    st.subheader("Informations professionnelles")
+    professional_info = current_user.get('professional_info', {})
+    if isinstance(professional_info, str):
+        import json
+        professional_info = json.loads(professional_info)
+    
+    new_profession = st.text_input(
+        "Profession",
+        value=professional_info.get('profession', '')
+    )
+    new_entreprise = st.text_input(
+        "Entreprise",
+        value=professional_info.get('entreprise', '')
+    )
+    
+    submit_personal = st.form_submit_button("Mettre à jour mes informations")
+    
+    if submit_personal:
+        try:
+            # Préparer les données à mettre à jour
+            update_data = {
+                "nom": new_nom,
+                "prenom": new_prenom,
+                "professional_info": {
+                    "profession": new_profession,
+                    "entreprise": new_entreprise
+                }
+            }
+            
+            # Mettre à jour dans la base de données
+            supabase.table("users").update(update_data).eq("id", user_id).execute()
+            st.success("✅ Informations personnelles mises à jour avec succès!")
+            st.rerun()  # Recharger la page pour afficher les nouvelles informations
+            # Notifier l'utilisateur
+        except Exception as e:
+            st.error(f"Une erreur est survenue : {str(e)}")
+            notify_security_alert(user_id, # notifier l'utilisateur du changement de ses impofrmations personnelles
+            "Vos informations personnelles ont été mises à jour."
+            )
+
+
+# Section Email et Mot de passe
+st.header("🔐 Email et Mot de passe")
+with st.form("security_form"):
+    # Email
+    new_email = st.text_input("Email", value=current_user.get('email', ''))
+    
+    # Mot de passe
+    st.subheader("Changer le mot de passe")
+    current_password = st.text_input("Mot de passe actuel", type="password")
+    new_password = st.text_input("Nouveau mot de passe", type="password")
+    confirm_password = st.text_input("Confirmer le nouveau mot de passe", type="password")
+    
+    submit_security = st.form_submit_button("Mettre à jour les informations de sécurité")
+    
+    if submit_security:
+        try:
+            update_data = {}
+            
+            # Vérifier si l'email a changé
+            if new_email != current_user.get('email'):
+                # Vérifier si le nouvel email existe déjà
+                existing_email = supabase.table("users").select("id").eq("email", new_email).neq("id", user_id).execute()
+                if existing_email.data:
+                    st.error("Cet email est déjà utilisé par un autre utilisateur.")
+                else:
+                    update_data["email"] = new_email
+            
+            # Vérifier si le mot de passe doit être mis à jour
+            if current_password and new_password and confirm_password:
+                # Vérifier l'ancien mot de passe
+                if not bcrypt.checkpw(current_password.encode(), current_user['password'].encode()):
+                    st.error("Le mot de passe actuel est incorrect.")
+                elif new_password != confirm_password:
+                    st.error("Les nouveaux mots de passe ne correspondent pas.")
+                elif len(new_password) < 8:
+                    st.error("Le nouveau mot de passe doit contenir au moins 8 caractères.")
+                else:
+                    # Hasher le nouveau mot de passe
+                    hashed_password = bcrypt.hashpw(new_password.encode(), bcrypt.gensalt()).decode()
+                    update_data["password"] = hashed_password
+            
+            # Effectuer la mise à jour si nécessaire
+            if update_data:
+                supabase.table("users").update(update_data).eq("id", user_id).execute()
+                st.success("✅ Informations de sécurité mises à jour avec succès!")
+                if "email" in update_data:
+                    st.warning("⚠️ Votre email a été modifié. Vous devrez vous reconnecter.")
+                    st.session_state.clear()
+                    st.rerun()
+            else:
+                st.info("Aucune modification à effectuer.")
+                
+        except Exception as e:
+            st.error(f"Une erreur est survenue : {str(e)}")
+
+
+
+# Section Préférences de Notification
+st.header("🔔 Préférences de Notification")
+
+# Récupérer les préférences actuelles
+notification_prefs = supabase.table("notification_preferences").select("*").eq("user_id", user_id).execute()
+current_prefs = notification_prefs.data[0] if notification_prefs.data else {
+    "email_notifications": True,
+    "security_alerts": True,
+    "assistant_updates": True,
+    "daily_summary": False
+}
+
+with st.form("notification_preferences_form"):
+    st.markdown("Choisissez les notifications que vous souhaitez recevoir :")
+    
+    email_notif = st.toggle(
+        "Notifications par email",
+        value=current_prefs.get("email_notifications", True),
+        help="Recevoir les notifications par email"
+    )
+    
+    security_alerts = st.toggle(
+        "Alertes de sécurité",
+        value=current_prefs.get("security_alerts", True),
+        help="Notifications concernant la sécurité de votre compte"
+    )
+    
+    assistant_updates = st.toggle(
+        "Mises à jour des assistants",
+        value=current_prefs.get("assistant_updates", True),
+        help="Notifications sur les nouvelles fonctionnalités des assistants"
+    )
+    
+    daily_summary = st.toggle(
+        "Résumé quotidien",
+        value=current_prefs.get("daily_summary", False),
+        help="Recevoir un résumé quotidien de vos interactions avec les assistants"
+    )
+    
+    submit_notif = st.form_submit_button("Enregistrer mes préférences")
+    
+    if submit_notif:
+        try:
+            # Préparer les données
+            notif_data = {
+                "user_id": user_id,
+                "email_notifications": email_notif,
+                "security_alerts": security_alerts,
+                "assistant_updates": assistant_updates,
+                "daily_summary": daily_summary,
+                "updated_at": "NOW()"
+            }
+            
+            # Vérifier si des préférences existent déjà
+            if notification_prefs.data:
+                # Mettre à jour les préférences existantes
+                supabase.table("notification_preferences").update(notif_data).eq("user_id", user_id).execute()
+            else:
+                # Créer de nouvelles préférences
+                notif_data["created_at"] = "NOW()"
+                supabase.table("notification_preferences").insert(notif_data).execute()
+            
+            st.success("✅ Préférences de notification mises à jour avec succès!")
+        except Exception as e:
+            st.error(f"Une erreur est survenue : {str(e)}")
+
+
+
+# Maintenant que nous avons implémenté le système de préférences de notification dans le fichoer actuel, nous  ajoutons la fonctionnalité pour envoyer effectivement ces notifications aux utilisateurs.
+# Nous  créyons un nouveau module pour gérer l'envoi des notifications. 
+# Voici les étapes :
+# Créez un nouveau fichier utils/notification_handler.py qui gérera l'envoi des notifications.
+
+
+
+# tester les notification (fonctions temporaires à supprimer en prod)
+st.header("🧪 Test des Notifications")
+
+test_col1, test_col2 = st.columns(2)
+
+with test_col1:
+    with st.form("test_security_notification"):
+        st.subheader("Test Alerte de Sécurité")
+        test_security_msg = st.text_input(
+            "Message de test (sécurité)",
+            value="Ceci est un test d'alerte de sécurité"
+        )
+        if st.form_submit_button("Tester Alerte Sécurité"):
+            from utils.notification_handler import notify_security_alert
+            if notify_security_alert(user_id, test_security_msg):
+                st.success("✅ Notification de sécurité envoyée!")
+            else:
+                st.error("❌ Erreur lors de l'envoi de la notification")
+
+with test_col2:
+    with st.form("test_assistant_notification"):
+        st.subheader("Test Mise à jour Assistant")
+        test_assistant_msg = st.text_input(
+            "Message de test (assistant)",
+            value="Ceci est un test de mise à jour assistant"
+        )
+        if st.form_submit_button("Tester Notification Assistant"):
+            from utils.notification_handler import notify_assistant_update
+            if notify_assistant_update(user_id, test_assistant_msg):
+                st.success("✅ Notification assistant envoyée!")
+            else:
+                st.error("❌ Erreur lors de l'envoi de la notification")
+
+# Test du résumé quotidien
+with st.form("test_daily_summary"):
+    st.subheader("Test Résumé Quotidien")
+    test_summary = {
+        "conversations": 5,
+        "questions": 15,
+        "usage_time": 45
+    }
+    
+    st.write("Données de test :")
+    st.json(test_summary)
+    
+    if st.form_submit_button("Tester Résumé Quotidien"):
+        from utils.notification_handler import send_daily_summary
+        if send_daily_summary(user_id, test_summary):
+            st.success("✅ Résumé quotidien envoyé!")
+        else:
+            st.error("❌ Erreur lors de l'envoi du résumé")

pages/reset_password.py

@@ -0,0 +1,67 @@
+import streamlit as st
+import sys
+import os
+import time
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from utils.password_reset import verify_reset_token, reset_password
+
+# Configuration de la page pour cacher complètement la sidebar
+st.set_page_config(
+    page_title="Réinitialisation du mot de passe",
+    page_icon="🔒",
+    layout="centered",
+    initial_sidebar_state="collapsed"
+)
+
+# Cacher tous les éléments de la sidebar et le menu hamburger
+hide_streamlit_style = """
+<style>
+    #MainMenu {visibility: hidden;}
+    header {visibility: hidden;}
+    .css-1544g2n {display: none;}
+    .css-14xtw13 e8zbici0 {display: none;}
+    section[data-testid="stSidebar"] {display: none;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+
+# Titre de la page
+st.title("Réinitialisation du mot de passe")
+
+# Récupérer le token depuis l'URL
+token = st.query_params.get("token", None)
+
+if not token:
+    st.error("Token de réinitialisation manquant.")
+    st.stop()
+
+# Vérifier la validité du token
+valid, user_id = verify_reset_token(token)
+
+if not valid:
+    st.error("Le lien de réinitialisation est invalide ou a expiré.")
+    time.sleep(3)  # Attendre 3 secondes
+    st.switch_page("app.py")  # Rediriger vers la page de connexion
+    st.stop()
+    
+# Formulaire de nouveau mot de passe
+with st.form("reset_password_form"):
+    new_password = st.text_input("Nouveau mot de passe", type="password")
+    confirm_password = st.text_input("Confirmez le mot de passe", type="password")
+    
+    submitted = st.form_submit_button("Réinitialiser le mot de passe")
+    
+    if submitted:
+        if new_password != confirm_password:
+            st.error("Les mots de passe ne correspondent pas.")
+        elif len(new_password) < 8:
+            st.error("Le mot de passe doit contenir au moins 8 caractères.")
+        else:
+            success, message = reset_password(token, new_password)
+            if success:
+                st.success("Votre mot de passe a été mis à jour avec succès.")
+                st.info("Redirection vers la page de connexion...")
+                time.sleep(3)  # Attendre 3 secondes
+                st.switch_page("app.py")  # Rediriger vers la page de connexion
+            else:
+                st.error(message)

utils/admin.py

@@ -0,0 +1,216 @@
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime
+import pytz
+from supabase import Client, create_client
+import os
+from dotenv import load_dotenv
+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 # logging  définis et importés depuis  le fichier dédié: logging_utils.py
+   
+    
+"""
+le fichier utils/admin.py gère :
+La gestion des utilisateurs
+Les permissions des assistants
+Les statistiques utilisateurs
+Les mises à jour des informations utilisateur
+
+Pour tester les modifications après, nous pourrons :
+Nous connecter en tant qu'administrateur
+Effectuer des opérations dans le dashboard admin (modifier un utilisateur, changer des permissions, etc.)
+""" 
+
+
+# Charger les variables d'environnement
+load_dotenv()
+supabase: Client = create_client(os.getenv("SUPABASE_URL"), os.getenv("SUPABASE_KEY"))
+
+
+def get_all_users() -> List[Dict]:
+    """
+    Récupère la liste de tous les utilisateurs (fonction admin).
+    
+    Returns:
+        List[Dict]: Liste des utilisateurs avec leurs informations
+    """
+    try:
+        response = supabase.table("users").select("*").execute()
+        return response.data if response.data else []
+    except Exception as e:
+        log_to_file(f"Erreur lors de la récupération des utilisateurs : {str(e)}", level=logging.ERROR)
+        return []
+
+def toggle_user_status(user_id: int, is_active: bool) -> Tuple[bool, str]:
+    """
+    Active ou désactive un compte utilisateur (fonction admin).
+    
+    Args:
+        user_id (int): ID de l'utilisateur
+        is_active (bool): Nouvel état du compte
+    
+    Returns:
+        Tuple[bool, str]: (Succès, Message)
+    """
+    try:
+        supabase.table("users").update({"is_active": is_active}).eq("id", user_id).execute()
+        status = "activé" if is_active else "désactivé"
+        return True, f"Compte utilisateur {status} avec succès"
+    except Exception as e:
+        log_to_file(f"Erreur lors de la modification du statut utilisateur : {str(e)}", level=logging.ERROR)
+        return False, f"Erreur lors de la modification du statut : {str(e)}"
+
+def change_user_role(user_id: int, new_role: str) -> Tuple[bool, str]:
+    """
+    Modifie le rôle d'un utilisateur (fonction admin).
+    
+    Args:
+        user_id (int): ID de l'utilisateur
+        new_role (str): Nouveau rôle ('admin' ou 'user')
+    
+    Returns:
+        Tuple[bool, str]: (Succès, Message)
+    """
+    if new_role not in ['admin', 'user']:
+        return False, "Rôle invalide"
+    
+    try:
+        supabase.table("users").update({"role": new_role}).eq("id", user_id).execute()
+        return True, f"Rôle modifié avec succès en {new_role}"
+    except Exception as e:
+        log_to_file(f"Erreur lors de la modification du rôle : {str(e)}", level=logging.ERROR)
+        return False, f"Erreur lors de la modification du rôle : {str(e)}"
+
+def get_user_stats() -> Dict:
+    """
+    Récupère des statistiques sur les utilisateurs (fonction admin).
+    
+    Returns:
+        Dict: Statistiques des utilisateurs
+    """
+    try:
+        total = supabase.table("users").select("count", count="exact").execute()
+        active = supabase.table("users").select("count", count="exact").eq("is_active", True).execute()
+        admins = supabase.table("users").select("count", count="exact").eq("role", "admin").execute()
+        
+        return {
+            "total_users": total.count if hasattr(total, 'count') else 0,
+            "active_users": active.count if hasattr(active, 'count') else 0,
+            "admin_users": admins.count if hasattr(admins, 'count') else 0,
+            "last_updated": datetime.now(pytz.UTC).isoformat()
+        }
+    except Exception as e:
+        log_to_file(f"Erreur lors de la récupération des statistiques : {str(e)}", level=logging.ERROR)
+        return {
+            "total_users": 0,
+            "active_users": 0,
+            "admin_users": 0,
+            "error": str(e)
+        }
+
+def update_user_info(user_id: int, updates: Dict) -> Tuple[bool, str]:
+    """
+    Met à jour les informations d'un utilisateur (fonction admin).
+    
+    Args:
+        user_id (int): ID de l'utilisateur
+        updates (Dict): Dictionnaire contenant les champs à mettre à jour
+    
+    Returns:
+        Tuple[bool, str]: (Succès, Message)
+    """
+    allowed_fields = {'nom', 'prenom', 'email', 'professional_info', 'is_active', 'role'}
+    update_data = {k: v for k, v in updates.items() if k in allowed_fields}
+    
+    if not update_data:
+        return False, "Aucun champ valide à mettre à jour"
+    
+    try:
+        supabase.table("users").update(update_data).eq("id", user_id).execute()
+        return True, "Informations utilisateur mises à jour avec succès"
+    except Exception as e:
+        log_to_file(f"Erreur lors de la mise à jour des informations utilisateur : {str(e)}", level=logging.ERROR)
+        return False, f"Erreur lors de la mise à jour : {str(e)}"
+    
+def get_user_permissions(user_id: int) -> Dict[str, bool]:
+    """
+    Récupère les autorisations d'accès aux assistants pour un utilisateur.
+    """
+    try:
+        response = supabase.table("user_assistant_permissions").select(
+            "assistant_type", "is_authorized"
+        ).eq("user_id", user_id).execute()
+        
+        # Convertir la réponse en dictionnaire
+        permissions = {
+            'insuranceSANTE': False,
+            'insuranceCAR': False,
+            'insuranceBTP': False,
+            'RH': False,
+            'Pilotage': False
+        }
+        if response.data:
+            for perm in response.data:
+                permissions[perm['assistant_type']] = perm['is_authorized']
+        return permissions
+    except Exception as e:
+        log_to_file(f"Erreur lors de la récupération des permissions : {str(e)}", level=logging.ERROR)
+        return {
+            'insuranceSANTE': False,
+            'insuranceCAR': False,
+            'insuranceBTP': False,
+            'RH': False,
+            'Pilotage': False
+        }
+
+
+def update_user_permissions(user_id: int, assistant_type: str, is_authorized: bool) -> Tuple[bool, str]:
+    """
+    Met à jour les autorisations d'accès d'un utilisateur pour un assistant spécifique.
+    """
+    try:
+        # Convertir user_id en int standard Python
+        user_id = int(user_id)  # Ajoutez cette ligne
+        
+        # Vérifier si une permission existe déjà
+        existing = supabase.table("user_assistant_permissions").select("*").eq(
+            "user_id", user_id
+        ).eq("assistant_type", assistant_type).execute()
+
+        if existing.data:
+            # Mettre à jour la permission existante
+            supabase.table("user_assistant_permissions").update({
+                "is_authorized": is_authorized,
+                "modified_at": datetime.now(pytz.UTC).isoformat()
+            }).eq("user_id", user_id).eq("assistant_type", assistant_type).execute()
+        else:
+            # Créer une nouvelle permission
+            supabase.table("user_assistant_permissions").insert({
+                "user_id": user_id,
+                "assistant_type": assistant_type,
+                "is_authorized": is_authorized
+            }).execute()
+
+        return True, f"Autorisation {'accordée' if is_authorized else 'retirée'} avec succès"
+    except Exception as e:
+        log_to_file(f"Erreur lors de la mise à jour des permissions : {str(e)}", level=logging.ERROR)
+        return False, str(e)
+    
+
+def initialize_user_permissions(user_id: int) -> bool:
+    """
+    Initialise les permissions par défaut pour un nouvel utilisateur.
+    """
+    try:
+        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},
+        ]
+        
+        supabase.table("user_assistant_permissions").insert(default_permissions).execute()
+        return True
+    except Exception as e:
+        log_to_file(f"Erreur lors de l'initialisation des permissions : {str(e)}", level=logging.ERROR)
+        return False

utils/async_flowise.py

@@ -0,0 +1,198 @@
+import asyncio
+import aiohttp
+import logging
+from typing import Dict, Optional, Any, AsyncGenerator
+import json
+from datetime import datetime, timedelta
+import pytz
+from utils.logging_utils import log_to_file
+import os
+import hashlib
+from dotenv import load_dotenv
+from utils.rate_limiter import RateLimiter
+from utils.circuit_breaker import AsyncCircuitBreaker
+from utils.cache_manager import CacheManager
+
+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")
+
+class AsyncFlowiseClient:
+    def __init__(self):
+        """Initialise le client asynchrone pour Flowise"""
+        self.api_urls = {
+            'insuranceSANTE': FLOWISE_API_URL_SANTE,
+            'insuranceCAR': FLOWISE_API_URL_CAR,
+            'insuranceBTP': FLOWISE_API_URL_BTP,
+            'RH': FLOWISE_API_URL_RH,
+            'Pilotage': FLOWISE_API_URL_PILOTAGE
+        }
+        self.session = None
+        self.rate_limiter = RateLimiter(requests_per_second=5, burst_limit=10)
+        self.circuit_breaker = AsyncCircuitBreaker(
+            failure_threshold=5,
+            recovery_timeout=60,
+            half_open_timeout=30
+        )
+        self.cache_manager = CacheManager()
+
+    def _generate_cache_key(self, question: str, assistant_type: str) -> str:
+        """Génère une clé de cache unique pour une question"""
+        question_hash = hashlib.md5(question.encode()).hexdigest()
+        return f"assistant_response:{assistant_type}:{question_hash}"
+
+    def _clean_question(self, question: str) -> str:
+        """Nettoie la question des métadonnées"""
+        try:
+            data = json.loads(question)
+            if isinstance(data, dict) and "next_inputs" in data and "query" in data["next_inputs"]:
+                return data["next_inputs"]["query"]
+        except json.JSONDecodeError:
+            pass
+        return question
+
+    def _process_response(self, response_data: Any) -> Dict[str, str]:
+        """Extrait uniquement le texte de la réponse"""
+        try:
+            # Si c'est une chaîne, essayer de la parser comme JSON
+            if isinstance(response_data, str):
+                try:
+                    data = json.loads(response_data)
+                    if isinstance(data, dict) and "text" in data:
+                        return {"answer": data["text"]}
+                except json.JSONDecodeError:
+                    return {"answer": response_data}
+            
+            # Si c'est déjà un dictionnaire
+            if isinstance(response_data, dict) and "text" in response_data:
+                return {"answer": response_data["text"]}
+            
+            # Si on ne peut pas extraire le texte, retourner une erreur
+            return {"error": "Format de réponse non reconnu"}
+            
+        except Exception as e:
+            log_to_file(f"Erreur lors du traitement de la réponse : {str(e)}", level=logging.ERROR)
+            return {"error": "Format de réponse non reconnu"}
+
+    async def query_assistant_stream(self, question: str, assistant_type: str, user_id: Optional[str] = None) -> AsyncGenerator[str, None]:
+        """Envoie une requête en streaming à Flowise"""
+        if assistant_type not in self.api_urls:
+            log_to_file(f"Type d'assistant non valide : {assistant_type}", level=logging.ERROR)
+            yield json.dumps({"error": f"Type d'assistant non valide : {assistant_type}"})
+            return
+
+        if not await self.rate_limiter.acquire(user_id):
+            yield json.dumps({"error": "Trop de requêtes. Veuillez réessayer dans quelques instants."})
+            return
+
+        if not self.session:
+            self.session = aiohttp.ClientSession()
+
+        try:
+            url = self.api_urls[assistant_type]
+            clean_question = self._clean_question(question)
+            payload = {"question": clean_question}
+
+            async with self.session.post(url, json=payload) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    log_to_file(f"Erreur lors de la requête à {assistant_type}: {error_text}", level=logging.ERROR)
+                    yield json.dumps({"error": f"Erreur {response.status}: {error_text}"})
+                    return
+
+                async for chunk in response.content.iter_any():
+                    if chunk:
+                        try:
+                            text = chunk.decode('utf-8')
+                            processed_response = self._process_response(text)
+                            if "answer" in processed_response:
+                                yield processed_response["answer"]
+                        except Exception as e:
+                            log_to_file(f"Erreur de décodage du chunk : {str(e)}", level=logging.ERROR)
+                            continue
+
+        except Exception as e:
+            error_message = str(e)
+            log_to_file(f"Erreur lors du streaming pour {assistant_type}: {error_message}", level=logging.ERROR)
+            yield json.dumps({"error": error_message})
+
+    async def query_assistant(self, question: str, assistant_type: str, user_id: Optional[str] = None) -> Dict[str, Any]:
+        """Envoie une requête asynchrone à Flowise avec cache"""
+        if assistant_type not in self.api_urls:
+            log_to_file(f"Type d'assistant non valide : {assistant_type}", level=logging.ERROR)
+            return {"error": f"Type d'assistant non valide : {assistant_type}"}
+
+        if not await self.rate_limiter.acquire(user_id):
+            return {"error": "Trop de requêtes. Veuillez réessayer dans quelques instants."}
+
+        cache_key = self._generate_cache_key(question, assistant_type)
+        cached_response = await self.cache_manager.get(cache_key)
+        
+        if cached_response:
+            log_to_file(f"Réponse trouvée dans le cache pour {assistant_type}", level=logging.INFO)
+            return cached_response
+
+        if not self.session:
+            self.session = aiohttp.ClientSession()
+
+        try:
+            url = self.api_urls[assistant_type]
+            clean_question = self._clean_question(question)
+            payload = {"question": clean_question}
+
+            async with self.session.post(url, json=payload) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    log_to_file(f"Erreur lors de la requête à {assistant_type}: {error_text}", level=logging.ERROR)
+                    return {"error": f"Erreur {response.status}: {error_text}"}
+
+                response_text = await response.text()
+                processed_response = self._process_response(response_text)
+                
+                if "error" not in processed_response:
+                    await self.cache_manager.set(
+                        cache_key, 
+                        processed_response, 
+                        expiry=timedelta(hours=1)
+                    )
+                    log_to_file(f"Réponse mise en cache pour {assistant_type}", level=logging.INFO)
+                
+                return processed_response
+
+        except Exception as e:
+            error_message = str(e)
+            if "Circuit breaker ouvert" in error_message:
+                log_to_file(f"Service {assistant_type} temporairement indisponible (Circuit breaker)", level=logging.ERROR)
+                return {"error": "Service temporairement indisponible. Veuillez réessayer plus tard."}
+            
+            log_to_file(f"Erreur lors de la requête à {assistant_type}: {error_message}", level=logging.ERROR)
+            return {"error": error_message}
+
+    async def check_health(self) -> Dict[str, bool]:
+        """Vérifie la santé des connexions aux différents assistants"""
+        if not self.session:
+            self.session = aiohttp.ClientSession()
+
+        results = {}
+        for assistant_type, url in self.api_urls.items():
+            try:
+                base_url = '/'.join(url.split('/')[:-4])  # Obtenir l'URL de base
+                async with self.session.get(
+                    f"{base_url}/health",
+                    timeout=aiohttp.ClientTimeout(total=5)
+                ) as response:
+                    results[assistant_type] = response.status == 200
+                    log_to_file(f"Statut santé {assistant_type}: {response.status}", level=logging.INFO)
+            except Exception as e:
+                log_to_file(f"Erreur de santé pour {assistant_type}: {str(e)}", level=logging.ERROR)
+                results[assistant_type] = False
+
+        return results
+
+    async def close(self):
+        """Ferme la session client"""
+        if self.session:
+            await self.session.close()
+            self.session = None

utils/auth_cache.py

@@ -0,0 +1,277 @@
+import json
+from datetime import datetime, timedelta
+import pytz
+from typing import Optional, List, Dict, Any
+import logging
+from utils.logging_utils import log_to_file
+from utils.cache_manager import CacheManager
+from utils.admin import supabase
+
+class AuthenticationCache:
+    def __init__(self):
+        self.cache_manager = CacheManager() # initialise la connexion Redis
+        self.cache_duration = timedelta(hours=24) # Duree de validité du cache (24h)
+        self.cache_version_key = "auth_cache_version"  # Pour suivre la version du cache
+        self.batch_size = 2  # Taille du batch pour le chargement par lots
+        self.session_cache_key = "user_session:"
+        self.history_cache_key = "chat_history:"  # Ajout de cet attribut
+
+    async def is_cache_initialized(self) -> bool:
+        """Vérifie si le cache est déjà initialisé"""
+        try:
+            all_keys = self.cache_manager.redis_client.keys("auth_user:*")
+            return len(all_keys) > 0
+        except Exception as e:
+            log_to_file(f"Erreur lors de la vérification du cache : {str(e)}", level=logging.ERROR)
+            return False
+
+    async def get_cache_version(self) -> str:
+        """Récupère la version actuelle du cache"""
+        try:
+            return await self.cache_manager.get(self.cache_version_key) or ""
+        except Exception as e:
+            log_to_file(f"Erreur lors de la récupération de la version du cache : {str(e)}", level=logging.ERROR)
+            return ""
+
+    async def update_cache_version(self) -> None:
+        """Met à jour la version du cache"""
+        try:
+            current_time = datetime.now(pytz.UTC).isoformat()
+            await self.cache_manager.set(self.cache_version_key, current_time, expiry=self.cache_duration)
+        except Exception as e:
+            log_to_file(f"Erreur lors de la mise à jour de la version du cache : {str(e)}", level=logging.ERROR)
+
+    async def is_cache_outdated(self) -> bool:
+        """Vérifie si le cache doit être mis à jour"""
+        try:
+            # Vérifier la dernière mise à jour du cache
+            cache_version = await self.get_cache_version()
+            if not cache_version:
+                return True
+
+            # Vérifier les modifications récentes dans Supabase
+            last_update = datetime.fromisoformat(cache_version)
+            recent_changes = supabase.table("users").select("updated_at").gt(
+                "updated_at", last_update.isoformat()
+            ).execute()
+
+            return bool(recent_changes.data)
+        except Exception as e:
+            log_to_file(f"Erreur lors de la vérification de l'état du cache : {str(e)}", level=logging.ERROR)
+            return True
+
+    async def get_user_from_cache(self, email: str) -> Optional[Dict[str, Any]]:
+        """Récupère les informations utilisateur depuis le cache.
+        Args:
+            email: L'adresse email de l'utilisateur à rechercher dans le cache.
+
+        Returns:
+            Un dictionnaire contenant les informations de l'utilisateur si trouvé dans le cache, None sinon.
+        """
+        try:
+            # Construit la clé de cache en utilisant l'email.
+            cache_key = f"auth_user:{email}"
+            # Récupère l'utilisateur depuis le cache en utilisant la clé.
+            return await self.cache_manager.get(cache_key)
+        except Exception as e:
+            # Enregistre une erreur si une exception se produit pendant la récupération du cache.
+            log_to_file(f"Erreur lors de la récupération du cache utilisateur : {str(e)}", level=logging.ERROR)
+            # Retourne None en cas d'erreur.
+            return None
+
+    async def set_user_in_cache(self, user_data: Dict[str, Any]) -> bool:
+        """Stocke les informations utilisateur dans le cache"""
+        try:
+            cache_key = f"auth_user:{user_data['email']}"
+            return await self.cache_manager.set(cache_key, user_data, expiry=self.cache_duration)
+        except Exception as e:
+            log_to_file(f"Erreur lors du stockage en cache : {str(e)}", level=logging.ERROR)
+            return False
+
+    async def load_all_users_to_cache(self) -> bool:
+        try:
+            log_to_file("Début du chargement des utilisateurs dans Redis", level=logging.INFO)
+            
+            # Récupérer le nombre total d'utilisateurs
+            total_users = supabase.table("users").select("id", count="exact").execute()
+            total_count = total_users.count
+            log_to_file(f"Nombre total d'utilisateurs : {total_count}", level=logging.INFO)
+            
+            # Charger les utilisateurs par lots
+            loaded_count = 0
+            for offset in range(0, total_count, self.batch_size):
+                log_to_file(f"Chargement du lot {offset} - {offset + self.batch_size - 1}", level=logging.INFO)
+                users = supabase.table("users").select("*").range(offset, offset + self.batch_size - 1).execute()
+                if users.data:
+                    for user in users.data:
+                        if await self.set_user_in_cache(user):
+                            loaded_count += 1
+                            log_to_file(f"Utilisateur {user['email']} mis en cache", level=logging.INFO)
+                        else:
+                            log_to_file(f"Échec du chargement de l'utilisateur : {user['email']}", level=logging.ERROR)
+                else:
+                    log_to_file(f"Aucun utilisateur trouvé dans la plage {offset} - {offset + self.batch_size - 1}", level=logging.WARNING)
+            
+            log_to_file(f"Chargement terminé : {loaded_count}/{total_count} utilisateurs mis en cache", level=logging.INFO)
+            
+            # Mettre à jour la version du cache
+            await self.update_cache_version()
+            
+            # Debug
+            await self.debug_redis_content()
+            
+            return True
+        except Exception as e:
+            log_to_file(f"Erreur lors du chargement des utilisateurs : {str(e)}", level=logging.ERROR)
+            return False
+
+
+    async def sync_cache_with_db(self) -> bool:
+        """Synchronise le cache avec la base de données"""
+        try:
+            cache_version = await self.get_cache_version()
+            if not cache_version:
+                return await self.load_all_users_to_cache()
+
+            last_update = datetime.fromisoformat(cache_version)
+            updated_users = supabase.table("users").select("*").gt(
+                "updated_at", last_update.isoformat()
+            ).execute()
+
+            if updated_users.data:
+                for user in updated_users.data:
+                    await self.set_user_in_cache(user)
+                await self.update_cache_version()
+                log_to_file(f"Cache mis à jour avec {len(updated_users.data)} modifications", level=logging.INFO)
+
+            return True
+        except Exception as e:
+            log_to_file(f"Erreur lors de la synchronisation du cache : {str(e)}", level=logging.ERROR)
+            return False
+
+
+    async def load_user_sessions_to_cache(self) -> bool:
+        """Charge toutes les sessions actives dans Redis"""
+        try:
+            log_to_file("Chargement des sessions utilisateurs dans Redis", level=logging.INFO)
+            
+            # Récupérer toutes les sessions actives
+            sessions = supabase.table("chat_sessions").select("*").eq(
+                "is_active", True
+            ).execute()
+            
+            if not sessions.data:
+                log_to_file("Aucune session active trouvée", level=logging.INFO)
+                return True
+
+            # Charger chaque session dans Redis
+            for session in sessions.data:
+                session_key = f"{self.session_cache_key}{session['user_id']}"
+                await self.cache_manager.set(
+                    session_key,
+                    session,
+                    expiry=self.cache_duration
+                )
+
+                # Charger l'historique associé
+                history = supabase.table("messages").select("*").eq(
+                    "session_id", session['session_id']
+                ).order('created_at', desc=False).execute()
+
+                if history.data:
+                    history_key = f"{self.history_cache_key}{session['session_id']}"
+                    await self.cache_manager.set(
+                        history_key,
+                        history.data,
+                        expiry=self.cache_duration
+                    )
+
+            log_to_file(f"Sessions et historiques chargés : {len(sessions.data)} sessions", level=logging.INFO)
+            return True
+            
+        except Exception as e:
+            log_to_file(f"Erreur lors du chargement des sessions : {str(e)}", level=logging.ERROR)
+            return False
+
+    async def get_active_session(self, user_id: int) -> Optional[Dict]:
+        """Récupère la session active d'un utilisateur depuis le cache"""
+        try:
+            session_key = f"{self.session_cache_key}{user_id}"
+            session = await self.cache_manager.get(session_key)
+            
+            if not session:
+                # Si pas dans le cache, chercher dans Supabase et mettre en cache
+                db_session = supabase.table("chat_sessions").select("*").eq(
+                    "user_id", user_id
+                ).eq("is_active", True).execute()
+                
+                if db_session.data:
+                    session = db_session.data[0]
+                    await self.cache_manager.set(
+                        session_key,
+                        session,
+                        expiry=self.cache_duration
+                    )
+            
+            return session
+        except Exception as e:
+            log_to_file(f"Erreur lors de la récupération de la session : {str(e)}", level=logging.ERROR)
+            return None
+
+    async def get_chat_history(self, session_id: str) -> List[Dict]:
+        """Récupère l'historique du chat depuis le cache"""
+        try:
+            history_key = f"{self.history_cache_key}{session_id}"
+            history = await self.cache_manager.get(history_key)
+
+            if not history:
+                # Si pas dans le cache, chercher dans Supabase et mettre en cache
+                db_history = supabase.table("messages").select("*").eq(
+                    "session_id", session_id
+                ).order('created_at', desc=False).execute()
+
+                if db_history.data:
+                    history = db_history.data
+                    await self.cache_manager.set(
+                        history_key,
+                        history,
+                        expiry=self.cache_duration
+                    )
+
+            return history or []
+        except Exception as e:
+            log_to_file(f"Erreur lors de la récupération de l'historique : {str(e)}", level=logging.ERROR)
+            return []
+
+    async def update_session_and_history(self, session_data: Dict, new_message: Dict = None):
+        """Met à jour la session et l'historique dans le cache"""
+        try:
+            session_key = f"{self.session_cache_key}{session_data['user_id']}"
+            await self.cache_manager.set(
+                session_key,
+                session_data,
+                expiry=self.cache_duration
+            )
+
+            if new_message:
+                history_key = f"{self.history_cache_key}{session_data['session_id']}"
+                current_history = await self.get_chat_history(session_data['session_id'])
+                current_history.append(new_message)
+                await self.cache_manager.set(
+                    history_key,
+                    current_history,
+                    expiry=self.cache_duration
+                )
+        except Exception as e:
+            log_to_file(f"Erreur lors de la mise à jour de la session : {str(e)}", level=logging.ERROR)
+
+
+    async def debug_redis_content(self):
+        """Affiche le contenu de Redis pour debug"""
+        try:
+            all_keys = self.cache_manager.redis_client.keys("auth_user:*")
+            log_to_file(f"Nombre d'utilisateurs en cache : {len(all_keys)}", level=logging.INFO)
+            for key in all_keys:
+                log_to_file(f"Utilisateur en cache : {key}", level=logging.INFO)
+        except Exception as e:
+            log_to_file(f"Erreur debug Redis : {str(e)}", level=logging.ERROR)

utils/cache_manager.py

@@ -0,0 +1,67 @@
+import redis
+import json
+import logging
+from typing import Any, Optional
+from datetime import timedelta
+import os
+from dotenv import load_dotenv
+from utils.logging_utils import log_to_file
+
+load_dotenv()
+
+class CacheManager:
+    def __init__(self):
+        """Initialise la connexion Redis"""
+        self.redis_client = redis.Redis(
+            host=os.getenv("REDIS_HOST"),
+            port=int(os.getenv("REDIS_PORT")),
+            decode_responses=True  # Pour automatiquement décoder les réponses en str
+        )
+        self.default_expiry = timedelta(hours=1)  # Expiration par défaut : 1 heure
+
+    async def get(self, key: str) -> Optional[Any]:
+        """Récupère une valeur du cache"""
+        try:
+            value = self.redis_client.get(key)
+            if value:
+                log_to_file(f"Cache hit pour la clé: {key}", level=logging.INFO)
+                return json.loads(value)
+            log_to_file(f"Cache miss pour la clé: {key}", level=logging.INFO)
+            return None
+        except Exception as e:
+            log_to_file(f"Erreur lors de la lecture du cache: {str(e)}", level=logging.ERROR)
+            return None
+
+    async def set(self, key: str, value: Any, expiry: Optional[timedelta] = None) -> bool:
+        """Enregistre une valeur dans le cache"""
+        try:
+            expiry_seconds = int((expiry or self.default_expiry).total_seconds())
+            success = self.redis_client.setex(
+                key,
+                expiry_seconds,
+                json.dumps(value)
+            )
+            if success:
+                log_to_file(f"Valeur mise en cache pour la clé: {key}", level=logging.INFO)
+            return success
+        except Exception as e:
+            log_to_file(f"Erreur lors de l'écriture dans le cache: {str(e)}", level=logging.ERROR)
+            return False
+
+    async def delete(self, key: str) -> bool:
+        """Supprime une valeur du cache"""
+        try:
+            return bool(self.redis_client.delete(key))
+        except Exception as e:
+            log_to_file(f"Erreur lors de la suppression du cache: {str(e)}", level=logging.ERROR)
+            return False
+
+    async def clear_all(self) -> bool:
+        """Vide tout le cache"""
+        try:
+            self.redis_client.flushall()
+            log_to_file("Cache entièrement vidé", level=logging.INFO)
+            return True
+        except Exception as e:
+            log_to_file(f"Erreur lors du vidage du cache: {str(e)}", level=logging.ERROR)
+            return False

utils/circuit_breaker.py

@@ -0,0 +1,74 @@
+import asyncio
+from enum import Enum
+from datetime import datetime, timedelta
+import logging
+from typing import Optional, Callable, Any
+from utils.logging_utils import log_to_file
+
+class CircuitState(Enum):
+    CLOSED = "CLOSED"        # Circuit fermé - Opérations normales
+    OPEN = "OPEN"           # Circuit ouvert - Échecs détectés
+    HALF_OPEN = "HALF_OPEN" # Circuit semi-ouvert - Test de récupération
+
+class AsyncCircuitBreaker:
+    def __init__(
+        self,
+        failure_threshold: int = 5,
+        recovery_timeout: int = 60,
+        half_open_timeout: int = 30
+    ):
+        self.failure_threshold = failure_threshold
+        self.recovery_timeout = recovery_timeout
+        self.half_open_timeout = half_open_timeout
+        self.state = CircuitState.CLOSED
+        self.failure_count = 0
+        self.last_failure_time: Optional[datetime] = None
+        self.lock = asyncio.Lock()
+
+    async def call(self, func: Callable, *args, **kwargs) -> Any:
+        """Exécute la fonction avec la logique du circuit breaker"""
+        async with self.lock:
+            if self.state == CircuitState.OPEN:
+                if self._should_attempt_recovery():
+                    self.state = CircuitState.HALF_OPEN
+                    log_to_file("Circuit breaker passé en état HALF_OPEN", level=logging.INFO)
+                else:
+                    raise Exception("Circuit breaker ouvert - Service indisponible")
+
+            try:
+                result = await func(*args, **kwargs)
+                if self.state == CircuitState.HALF_OPEN:
+                    self._reset()
+                return result
+
+            except Exception as e:
+                await self._handle_failure(e)
+                raise
+
+    def _should_attempt_recovery(self) -> bool:
+        """Vérifie si on doit tenter une récupération"""
+        if not self.last_failure_time:
+            return True
+        
+        recovery_time = self.last_failure_time + timedelta(seconds=self.recovery_timeout)
+        return datetime.now() > recovery_time
+
+    async def _handle_failure(self, exception: Exception) -> None:
+        """Gère un échec d'appel"""
+        self.failure_count += 1
+        self.last_failure_time = datetime.now()
+        
+        if self.state == CircuitState.HALF_OPEN or self.failure_count >= self.failure_threshold:
+            self.state = CircuitState.OPEN
+            log_to_file(f"Circuit breaker ouvert après {self.failure_count} échecs", level=logging.WARNING)
+
+    def _reset(self) -> None:
+        """Réinitialise le circuit breaker"""
+        self.state = CircuitState.CLOSED
+        self.failure_count = 0
+        self.last_failure_time = None
+        log_to_file("Circuit breaker réinitialisé et fermé", level=logging.INFO)
+
+    def get_state(self) -> CircuitState:
+        """Retourne l'état actuel du circuit breaker"""
+        return self.state

utils/email_utils.py

@@ -0,0 +1,100 @@
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+import os
+from dotenv import load_dotenv
+from typing import Optional
+from utils.logging_utils import log_to_file # remplace "import logging" car maintenat les logging sont définis et importés depuis  le fichier dédié: logging_utils.py
+
+load_dotenv()
+
+# Configuration email
+EMAIL_HOST = os.getenv("EMAIL_HOST", "smtp.gmail.com")
+EMAIL_PORT = int(os.getenv("EMAIL_PORT", "587"))
+EMAIL_HOST_USER = os.getenv("EMAIL_HOST_USER")
+EMAIL_HOST_USER_PASSWORD = os.getenv("EMAIL_HOST_USER_PASSWORD")
+DEFAULT_FROM_EMAIL = os.getenv("DEFAULT_FROM_EMAIL")
+
+"""
+Le fichier email_utils.py est responsable de l'envoi de tous les emails dans l'application, notamment :
+
+Les emails de vérification lors de l'inscription d'un nouvel utilisateur
+Les emails de réinitialisation de mot de passe quand un utilisateur clique sur "Mot de passe oublié"
+Les emails de notification (activité du compte, changements de permission, etc.)
+
+Pour tester les modifications :
+Essayez de créer un nouveau compte (pour tester l'email de vérification)
+Ou cliquez sur "Mot de passe oublié" sur la page de connexion
+"""
+
+# Configuration du logging
+#logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Tentative de chargement du .env
+env_path = '.env'
+if os.path.exists(env_path):
+    load_dotenv(env_path)
+    log_to_file(f"Fichier .env trouvé et chargé")
+    # Afficher les variables pour vérification
+    log_to_file(f"EMAIL_HOST: {os.getenv('EMAIL_HOST')}")
+    log_to_file(f"EMAIL_PORT: {os.getenv('EMAIL_PORT')}")
+    log_to_file(f"EMAIL_HOST_USER: {os.getenv('EMAIL_HOST_USER')}")
+    log_to_file(f"DEFAULT_FROM_EMAIL: {os.getenv('DEFAULT_FROM_EMAIL')}")
+    # Ne pas logger le mot de passe pour des raisons de sécurité
+else:
+    log_to_file(f"Fichier .env non trouvé à l'emplacement: {os.path.abspath(env_path)}")
+
+def create_smtp_connection() -> Optional[smtplib.SMTP]:
+    """
+    Crée et retourne une connexion SMTP sécurisée.
+    """
+    try:
+        server = smtplib.SMTP(EMAIL_HOST, EMAIL_PORT)
+        server.ehlo()  # Identifier le client au serveur
+        server.starttls()  # Activer le chiffrement TLS
+        server.login(EMAIL_HOST_USER, EMAIL_HOST_USER_PASSWORD)
+        return server
+    except Exception as e:
+        log_to_file(f"Erreur lors de la connexion SMTP : {str(e)}")
+        return None
+
+def send_email(to_email: str, subject: str, html_content: str) -> bool:
+    """
+    Envoie un email avec un contenu HTML.
+    """
+    if not all([EMAIL_HOST_USER, EMAIL_HOST_USER_PASSWORD, DEFAULT_FROM_EMAIL]):
+        log_to_file("Configuration email manquante dans le fichier .env")
+        return False
+
+    try:
+        # Création du message
+        msg = MIMEMultipart('alternative')
+        msg['Subject'] = subject
+        msg['From'] = DEFAULT_FROM_EMAIL
+        msg['To'] = to_email
+
+        # Ajout du contenu HTML
+        html_part = MIMEText(html_content, 'html')
+        msg.attach(html_part)
+
+        # Création de la connexion SMTP et envoi
+        server = create_smtp_connection()
+        if not server:
+            return False
+
+        try:
+            server.send_message(msg)
+            log_to_file(f"Email envoyé avec succès à {to_email}")
+            return True
+        except Exception as e:
+            log_to_file(f"Erreur lors de l'envoi de l'email : {str(e)}")
+            return False
+        finally:
+            try:
+                server.quit()
+            except:
+                pass
+
+    except Exception as e:
+        log_to_file(f"Erreur lors de la préparation de l'email : {str(e)}")
+        return False

utils/ip_utils.py

@@ -0,0 +1,19 @@
+import requests
+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é.
+
+
+def get_user_ip():
+    
+    """Récupère l'adresse IP publique de l'utilisateur.
+    Cette fonction utilise la bibliothèque requests pour récupérer l'adresse IP publique de l'utilisateur.
+    Si une erreur est rencontrée lors de la récupération de l'adresse IP, la fonction renvoie None.
+    """
+    try:
+        response = requests.get('https://api.ipify.org?format=json')
+        response.raise_for_status()  # Lever une exception si la requête a échoué
+        return response.json()['ip']
+    except requests.exceptions.RequestException as e:
+        # Gérer les erreurs de requête (connexion, timeout, etc.)
+        log_to_file(f"-(ip_utils.py/def get_user_ip():)Erreur lors de la récupération de l'adresse IP : {e}", level=logging.ERROR)
+        return None

utils/logging_utils.py

@@ -0,0 +1,14 @@
+import logging
+from datetime import datetime
+
+
+#Nouveau système de lod 
+def log_to_file(message, level=logging.INFO):
+    """Fonction centralisée pour la gestion des logs"""
+    logger = logging.getLogger(__name__)
+    logger.log(level, message)
+    
+    # Écrire également dans un fichier
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with open("app_logs.txt", "a") as log_file:
+        log_file.write(f"{timestamp} - {logging.getLevelName(level)} - {message}\n")

utils/notification_handler.py

@@ -0,0 +1,84 @@
+# utils/notification_handler.py (fichier en relation avec profile.py)
+import streamlit as st
+from utils.email_utils import send_email
+from utils.admin import supabase
+from datetime import datetime
+import pytz
+import logging
+
+def send_user_notification(user_id: int, notification_type: str, message: str) -> bool:
+    """
+    Envoie une notification à l'utilisateur en respectant ses préférences
+    """
+    try:
+        logging.info(f"Début de l'envoi de notification pour user_id: {user_id}, type: {notification_type}")
+        # Récupérer les préférences de l'utilisateur
+        user_prefs = supabase.table("notification_preferences").select("*").eq("user_id", user_id).execute()
+        user_info = supabase.table("users").select("email").eq("id", user_id).execute()
+        
+        if not user_prefs.data:
+            logging.error(f"Aucune préférence trouvée pour user_id: {user_id}")
+            return False
+        if not user_info.data:
+            logging.error(f"Aucun utilisateur trouvé pour user_id: {user_id}")
+            return False
+   
+        
+        prefs = user_prefs.data[0]
+        user_email = user_info.data[0]['email']
+        logging.info(f"Préférences trouvées pour {user_email}: {prefs}")
+
+        # Vérifier si les notifications sont activées pour ce type
+        if notification_type == "security" and not prefs['security_alerts']:
+            logging.info(f"Alertes de sécurité désactivées pour {user_email}")
+            return False
+        elif notification_type == "assistant" and not prefs['assistant_updates']:
+            logging.info(f"Mises à jour assistant désactivées pour {user_email}")
+            return False
+        elif notification_type == "daily" and not prefs['daily_summary']:
+            logging.info(f"Résumé quotidien désactivé pour {user_email}")
+            return False
+
+        # Si les notifications par email sont activées
+        logging.info(f"Envoi d'email à {user_email}")
+        success = send_email(user_email, 
+                           f"Notification - {notification_type.capitalize()}", 
+                           f"""
+            <html>
+                <body>
+                    <h2>Notification {notification_type}</h2>
+                    <p>{message}</p>
+                    <p>Date : {datetime.now(pytz.UTC).strftime('%Y-%m-%d %H:%M:%S UTC')}</p>
+                </body>
+            </html>
+            """)
+        
+        if success:
+            logging.info(f"Email envoyé avec succès à {user_email}")
+        else:
+            logging.error(f"Échec de l'envoi de l'email à {user_email}")
+        
+        return success
+            
+    except Exception as e:
+        logging.error(f"Erreur lors de l'envoi de la notification : {str(e)}")
+        logging.error(f"Traceback complet : ", exc_info=True)
+        return False
+
+def notify_security_alert(user_id: int, message: str) -> bool:
+    """Envoie une alerte de sécurité"""
+    return send_user_notification(user_id, "security", message)
+
+def notify_assistant_update(user_id: int, message: str) -> bool:
+    """Envoie une notification de mise à jour des assistants"""
+    return send_user_notification(user_id, "assistant", message)
+
+def send_daily_summary(user_id: int, summary_data: dict) -> bool:
+    """Envoie le résumé quotidien"""
+    message = f"""
+    Résumé de vos activités :
+    - Nombre de conversations : {summary_data.get('conversations', 0)}
+    - Questions posées : {summary_data.get('questions', 0)}
+    - Temps total d'utilisation : {summary_data.get('usage_time', '0')} minutes
+    """
+    return send_user_notification(user_id, "daily", message)

utils/password_reset.py

@@ -0,0 +1,159 @@
+import streamlit as st
+from datetime import datetime, timedelta
+import pytz
+import secrets
+import bcrypt
+from supabase import create_client
+import os
+from dotenv import load_dotenv
+from utils.email_utils import send_email
+from urllib.parse import urljoin, urlparse
+from utils.logging_utils import log_to_file # remplace "import logging" car maintenat les logging sont définis et importés depuis  le fichier dédié: logging_utils.py
+
+load_dotenv()
+supabase = create_client(os.getenv("SUPABASE_URL"), os.getenv("SUPABASE_KEY"))
+
+# Fonction pour générer un token de réinitialisation de mot de passe
+def generate_reset_token() -> str:
+    """Génère un token sécurisé pour la réinitialisation de mot de passe."""
+    return secrets.token_urlsafe(32)
+
+# Fonction pour créer un token de réinitialisation de mot de passe pour un utilisateur spécifique
+def create_reset_token(user_id: int) -> tuple[bool, str]:
+    """
+    Crée un token de réinitialisation de mot de passe.
+    """
+    try:
+        token = generate_reset_token()
+        expires_at = datetime.now(pytz.UTC) + timedelta(hours=24)
+        
+        # Invalider les tokens précédents
+        supabase.table("user_tokens").update({
+            "used": True
+        }).eq("user_id", user_id).eq("type", "reset_password").execute()
+        
+        # Créer un nouveau token
+        supabase.table("user_tokens").insert({
+            "user_id": user_id,
+            "token": token,
+            "type": "reset_password",
+            "expires_at": expires_at.isoformat()
+        }).execute()
+        
+        return True, token
+    except Exception as e:
+        log_to_file(f"Erreur lors de la création du token : {str(e)}")
+        return False, ""
+
+# Fonction pour envoyer l'email de réinitialisation
+def send_reset_email(email: str, reset_url: str) -> bool:
+    """
+    Envoie l'email de réinitialisation.
+    """
+    subject = "Réinitialisation de votre mot de passe"
+    html_content = f"""
+    <html>
+        <body>
+            <h2>Réinitialisation de votre mot de passe</h2>
+            <p>Vous avez demandé la réinitialisation de votre mot de passe.</p>
+            <p>Cliquez sur le lien ci-dessous pour définir un nouveau mot de passe :</p>
+            <p><a href="{reset_url}">Réinitialiser mon mot de passe</a></p>
+            <p>Ce lien est valable pendant 24 heures.</p>
+            <p>Si vous n'avez pas demandé cette réinitialisation, ignorez cet email.</p>
+        </body>
+    </html>
+    """
+    return send_email(email, subject, html_content)
+
+
+# Fonction pour initier le processus de réinitialisation du mot de passe
+def initiate_password_reset(email: str) -> tuple[bool, str]:
+    """
+    Initie le processus de réinitialisation de mot de passe.
+    """
+    try:
+        # Vérifier si l'utilisateur existe
+        user = supabase.table("users").select("id").eq("email", email).execute()
+        if not user.data:
+            return False, "Aucun compte associé à cet email."
+        
+        user_id = user.data[0]['id']
+        success, token = create_reset_token(user_id)
+        
+        if not success:
+            return False, "Erreur lors de la création du token."
+        
+        
+        # Construire l'URL de réinitialisation de manière sécurisée
+        base_url = os.getenv('APP_URL', '').rstrip('/')
+        # Nettoyer l'URL de base
+        if base_url.startswith('http://'):
+            base_url = base_url[7:]
+        elif base_url.startswith('https://'):
+            base_url = base_url[8:]
+            
+        base_url = base_url.strip('/')
+        reset_url = f"http://{base_url}/reset_password?token={token}"
+        
+        # Envoyer l'email
+        if send_reset_email(email, reset_url):
+            return True, "Instructions envoyées par email."
+        return False, "Erreur lors de l'envoi de l'email."
+        
+    except Exception as e:
+        log_to_file(f"Erreur lors de l'initiation de la réinitialisation : {str(e)}")
+        return False, "Une erreur est survenue."
+    
+
+# Fonction pour vérifier la validité d'un token de réinitialisation
+def verify_reset_token(token: str) -> tuple[bool, int]:
+    """
+    Vérifie la validité d'un token de réinitialisation.
+    """
+    try:
+        response = supabase.table("user_tokens").select("*").eq(
+            "token", token
+        ).eq("type", "reset_password").eq("used", False).execute()
+        
+        if not response.data:
+            return False, 0
+        
+        token_data = response.data[0]
+        expires_at = datetime.fromisoformat(token_data['expires_at'].replace('Z', '+00:00'))
+        
+        if expires_at < datetime.now(pytz.UTC):
+            return False, 0
+            
+        return True, token_data['user_id']
+    except Exception as e:
+        log_to_file(f"Erreur lors de la vérification du token : {str(e)}")
+        return False, 0
+    
+
+# Fonction pour réinitialiser le mot de passe avec le token de réinitialisation
+def reset_password(token: str, new_password: str) -> tuple[bool, str]:
+    """
+    Réinitialise le mot de passe avec le token.
+    """
+    try:
+        valid, user_id = verify_reset_token(token)
+        if not valid:
+            return False, "Token invalide ou expiré."
+        
+        # Hasher le nouveau mot de passe
+        hashed_password = bcrypt.hashpw(new_password.encode(), bcrypt.gensalt()).decode()
+        
+        # Mettre à jour le mot de passe
+        supabase.table("users").update({
+            "password": hashed_password
+        }).eq("id", user_id).execute()
+        
+        # Marquer le token comme utilisé
+        supabase.table("user_tokens").update({
+            "used": True
+        }).eq("token", token).execute()
+        
+        return True, "Mot de passe mis à jour avec succès."
+    except Exception as e:
+        log_to_file(f"Erreur lors de la réinitialisation du mot de passe : {str(e)}")
+        return False, "Une erreur est survenue."

utils/rate_limiter.py

@@ -0,0 +1,139 @@
+import asyncio
+import pytz
+from datetime import datetime, timedelta
+import time
+from typing import Dict, Optional
+import logging
+from utils.logging_utils import log_to_file
+from utils.admin import supabase  # Ajoutez cet import avec les autres
+from utils.cache_manager import CacheManager
+cache_manager = CacheManager() # optimiser les statistiques d'utilisation avec le cache
+
+class RateLimiter:
+    def __init__(self, requests_per_second: int = 10, burst_limit: int = 20): # 10 requetes par seconde, 20 requetes en rafale
+        """
+        Initialise le rate limiter
+        requests_per_second: Nombre maximal de requêtes par seconde
+        burst_limit: Nombre maximal de requêtes en rafale
+        """
+        self.rate = requests_per_second # Nombre maximal de requetes pas seconde (aujourd'hui) 
+        self.burst_limit = burst_limit # Nombre maximal de requetes en rafale (aujourd'hui)
+        self.tokens = burst_limit # Nombre de jetons restants  en rafale (aujourd'hui) 
+        self.last_update = time.monotonic() # Derniere mise à jour
+        self.lock = asyncio.Lock() # Prise en charge du verrouillage
+        self._requests_count: Dict[str, int] = {} # Compteur de requetes
+        self.last_cleanup = time.time() # Date du dernier nettoyage
+        self.cleanup_interval = 3600 # 1 heure en secondes pour le nettoyage au bout d'une heure 
+        self.cache_manager = CacheManager() # utilisation du cache pour stocker les statisqtiques d'utilisation (aujourd'hui)
+
+
+    async def acquire(self, user_id: Optional[str] = None) -> bool:
+        """Tente d'acquérir un token pour faire une requête"""
+        async with self.lock:
+            now = time.monotonic()
+            time_passed = now - self.last_update
+            self.tokens = min(
+                self.burst_limit,
+                self.tokens + time_passed * self.rate
+            )
+            self.last_update = now
+
+            if self.tokens >= 1:
+                self.tokens -= 1
+                if user_id:
+                    await self._track_request(user_id)
+                return True
+            
+            log_to_file(f"Rate limit atteint pour l'utilisateur {user_id}", level=logging.WARNING)
+            return False
+
+
+    async def _get_stats_from_cache(self, user_id: str) -> Optional[Dict]:
+        """Récupère les statistiques depuis le cache"""
+        cache_key = f"usage_stats:{user_id}"
+        return await cache_manager.get(cache_key)
+
+    async def _update_stats_cache(self, user_id: str, stats: Dict):
+        """Met à jour les statistiques dans le cache"""
+        cache_key = f"usage_stats:{user_id}"
+        await cache_manager.set(cache_key, stats, expiry=timedelta(hours=1))
+
+    async def _track_request(self, user_id: str) -> None:
+        """Suit les requêtes par utilisateur avec cache"""
+        try:
+            current_time = datetime.now(pytz.UTC).isoformat()
+            stats_data = None  # Initialiser stats_data
+        
+            # Vérifier d'abord le cache
+            cached_stats = await self._get_stats_from_cache(user_id)
+        
+            if cached_stats:
+                # Mettre à jour les stats en cache
+                cached_stats['request_count'] += 1
+                cached_stats['last_request'] = current_time
+                await self._update_stats_cache(user_id, cached_stats)
+                stats_data = cached_stats
+            
+                # Mettre à jour Supabase de manière asynchrone
+                supabase.table("usage_statistics").update({
+                    "request_count": cached_stats['request_count'],
+                    "last_request": current_time
+                }).eq("user_id", user_id).execute()
+            else:
+                # Vérifier Supabase
+                existing = supabase.table("usage_statistics").select("*").eq("user_id", user_id).execute()
+            
+                if existing.data:
+                    # Mettre à jour les stats existantes
+                    stats = existing.data[0]
+                    new_count = stats.get('request_count', 0) + 1
+                    stats_data = {
+                        "request_count": new_count,
+                        "last_request": current_time
+                    }
+                
+                    supabase.table("usage_statistics").update(stats_data).eq("user_id", user_id).execute()
+                    await self._update_stats_cache(user_id, stats_data)
+                else:
+                    # Créer nouvelles stats
+                    stats_data = {
+                        "user_id": user_id,
+                        "request_count": 1,
+                        "last_request": current_time,
+                        "last_cleanup": current_time
+                    }
+                
+                    supabase.table("usage_statistics").insert(stats_data).execute()
+                    await self._update_stats_cache(user_id, stats_data)
+
+            if stats_data:  # Vérifier que stats_data existe
+                self._requests_count[user_id] = stats_data['request_count']
+                log_to_file(f"Nouvelle requête pour l'utilisateur {user_id}. Total: {stats_data['request_count']}", level=logging.INFO)
+        
+        except Exception as e:
+            log_to_file(f"Erreur lors du suivi des requêtes: {str(e)}", level=logging.ERROR)
+            # Continuer avec le comptage en mémoire en cas d'erreur
+            if user_id not in self._requests_count:
+                self._requests_count[user_id] = 1
+            else:
+                self._requests_count[user_id] += 1
+
+
+
+
+    async def get_user_requests_count(self, user_id: str) -> int:
+        """Retourne le nombre de requêtes avec cache"""
+        try:
+            cached_stats = await self._get_stats_from_cache(user_id)
+            if cached_stats:
+                return cached_stats.get('request_count', 0)
+            
+            response = supabase.table("usage_statistics").select("request_count").eq("user_id", user_id).execute()
+            if response.data:
+                count = response.data[0].get('request_count', 0)
+                await self._update_stats_cache(user_id, {"request_count": count})
+                return count
+            return 0
+        except Exception as e:
+            log_to_file(f"Erreur lors de la récupération du compte des requêtes: {str(e)}", level=logging.ERROR)
+            return self._requests_count.get(user_id, 0)

utils/theme_utils.py

@@ -0,0 +1,558 @@
+import streamlit as st
+import base64
+import os
+from datetime import datetime
+import pytz
+import logging
+from utils.admin import supabase  # Pour load_theme_preference et save_theme_preference
+from utils.logging_utils import log_to_file
+
+
+# Fonction pour charger la préférence de thème depuis la base de données
+def load_theme_preference():
+    """Charge la préférence de thème depuis la base de données"""
+    if 'user' in st.session_state and st.session_state['user']:
+        user_id = st.session_state['user'].get('id')
+        if user_id:
+            try:
+                response = supabase.table("notification_preferences").select("theme").eq("user_id", user_id).execute()
+                if response.data:
+                    theme = response.data[0]['theme']
+                    log_to_file(f"Thème '{theme}' chargé pour l'utilisateur {user_id}")
+                    return theme
+            except Exception as e:
+                log_to_file(f"Erreur lors du chargement du thème : {str(e)}", logging.ERROR)
+    return 'Clair'  # Thème par défaut
+
+
+# Fonction pour sauvegarder la préférence de thème dans la base de données
+def save_theme_preference(theme):
+    """Sauvegarde la préférence de thème dans la base de données"""
+    if 'user' in st.session_state and st.session_state['user']:
+        user_id = st.session_state['user'].get('id')
+        if user_id:
+            try:
+                # Vérifier si une préférence existe déjà
+                existing_preference = supabase.table("notification_preferences").select("*").eq("user_id", user_id).execute()
+                
+                if existing_preference.data:
+                    # Mettre à jour la ligne existante
+                    supabase.table("notification_preferences").update({"theme": theme}).eq("user_id", user_id).execute()
+                else:
+                    # Insérer une nouvelle ligne
+                    supabase.table("notification_preferences").insert({"user_id": user_id, "theme": theme}).execute()
+                
+                st.session_state.user_theme = theme
+                log_to_file(f"Thème '{theme}' sauvegardé pour l'utilisateur {user_id}")
+            except Exception as e:
+                log_to_file(f"Erreur lors de la sauvegarde du thème : {str(e)}", logging.ERROR)
+
+
+def apply_theme(theme):
+    # Définition des couleurs communes selon le thème choisi (sombre ou clair)
+    
+    # Texte principal : Gris clair (#E0E0E0) pour le thème sombre, Gris foncé (#4a4a4a) pour le thème clair
+    text_color = "#E0E0E0" if theme == "Sombre" else "#4a4a4a"  
+    
+    # Couleur de fond de la page : Gris très foncé (#1E1E1E) pour le thème sombre, blanc cassé (#f7f9fc) pour le thème clair
+    bg_color = "#1E1E1E" if theme == "Sombre" else "#f7f9fc"  
+    
+    # Couleur de fond des zones de saisie (inputs) : Gris foncé (#333333) pour le thème sombre, gris très clair avec une légère teinte bleue (#eef3f7) pour le thème clair
+    input_bg_color= "#333333" if theme == "Sombre" else "#eef3f7" 
+
+    # Couleur de fond des zones de saisie (inputs) : Gris foncé (#333333) pour le thème sombre, rouge saumon clair (#ffcccb pour le thème clair
+    input_text_area_inactive = "#333333" if theme == "Sombre" else "#ffcccb"
+
+    # Couleur de fond des zones de saisie active (inputs) : Gris foncé (#999999) pour le thème sombre, Blanc pur (#ffffff) pour le thème clair
+    input_text_area_active = "#666666" if theme == "Sombre" else "#ffffff" 
+
+
+    # Définir la couleur du curseur (caret) selon le thème
+    caret_color = "white" if theme == "Sombre" else "black"  # Blanc pour le thème sombre, noir pour le thème clair
+    
+    # Couleur de fond de la barre latérale : Gris très foncé (#2D2D2D) pour le thème sombre, gris bleu très clair ( #e3e9f1) pour le thème clair
+    sidebar_bg_color = "#2D2D2D" if theme == "Sombre" else " #e3e9f1"  
+    
+    # Couleurs spécifiques pour les messages utilisateur et assistant :
+    
+    # Messages de l'utilisateur : Bleu foncé (#0E4C92) pour le thème sombre, Bleu clair désaturé (#d1e7ff) pour le thème clair
+    user_msg_bg = "#0E4C92" if theme == "Sombre" else "#d1e7ff"  
+    
+    # Messages de l'assistant : Vert foncé (#1A472A) pour le thème sombre, Gris perle (#f0f0f0) pour le thème clair
+    assistant_msg_bg = "#1A472A" if theme == "Sombre" else "#f0f0f0"  
+    
+    # Couleurs pour les boutons et éléments interactifs :
+    
+    # Fond des boutons : Bleu acier (#4682B4) pour le thème sombre, Or (#FFD700) pour le thème clair
+    button_bg = "#4682B4" if theme == "Sombre" else "#FFD700"  
+    
+    # Texte des boutons : Blanc (#FFFFFF) pour le thème sombre, Vert mer (#8FBC8F) pour le thème clair
+    button_text = "white" if theme == "Sombre" else "#8FBC8F"  
+    
+    # Fond du selectbox : Bleu foncé (#0E4C92) pour le thème sombre, gris très clair avec une légère teinte bleue (#eef3f7) pour le thème clair
+    select_bg = "#ff5e4d" if theme == "Sombre" else "#eef3f7"  
+
+    # Fond du selectbox : Bleu foncé (#0E4C92) pour le thème sombre, Gris clair (#e6f7ff) pour le thème clair
+    select_option_bg = "#1c39bb" if theme == "Sombre" else "#e6f7ff"  
+
+    select_text_color = "black" if theme == "Sombre" else "#333333"  # Couleur du texte du selectbox
+    
+    # Génération des styles CSS pour Streamlit
+    st.markdown(f"""
+    <style>
+    /* Styles généraux */
+    .stApp {{
+        background-color: {bg_color}; /* Couleur de fond générale */
+        color: {text_color} !important; /* Couleur de texte principale */
+    }}
+    
+    /* Styles pour les messages de chat */
+    .stChatMessage {{
+        background-color: {input_bg_color} !important; /* Fond des messages */
+        color: {text_color} !important; /* Couleur de texte dans les messages */
+    }}
+    .stChatMessage.user {{ background-color: {user_msg_bg} !important; }} /* Fond des messages utilisateur */
+    .stChatMessage.assistant {{ background-color: {assistant_msg_bg} !important; }} /* Fond des messages assistant */
+    .stChatMessage * {{ color: {text_color} !important; }} /* Couleur de texte dans tous les éléments des messages */
+    
+    /* Style pour le conteneur de la zone de saisie */
+    [data-testid="stBottomBlockContainer"] {{
+        background-color: {input_bg_color} !important; /* Fond de la zone de saisie */
+    }}
+    
+    /* Styles pour la zone de saisie et son conteneur interne */
+    .stChatInput,
+    .stChatInput > div,
+    .stChatInput textarea {{
+        background-color: {input_text_area_inactive} !important; /* Fond de la zone de saisie */
+        border-color: {"#555555" if theme == "Sombre" else "#b0e0e6"} !important; /* Bordure des champs de saisie */
+        color: {text_color} !important; /* Texte dans la zone de saisie */
+    }}
+    .stChatInput textarea:focus {{
+        background-color: {input_text_area_active} !important; /* Fond quand la zone est active */
+        color: {text_color} !important; /* Texte actif */
+        caret-color: {caret_color} !important; /* Couleur du curseur actif */
+        box-shadow: none !important; /* Pas de halo lumineux lors de la saisie */
+    }}
+
+    /* Style pour le bouton d'envoi */
+    .stChatInput button {{
+        background-color: {button_bg} !important; /* Fond des boutons */
+        color: {button_text} !important; /* Couleur du texte des boutons */
+    }}
+    
+    /* Styles pour la barre latérale */
+    [data-testid="stSidebar"] {{
+        background-color: {sidebar_bg_color}; /* Couleur de fond de la barre latérale */
+        color: {text_color}; /* Texte de la barre latérale */
+    }}
+    [data-testid="stSidebar"] .st-bw,
+    [data-testid="stSidebar"] h3 {{ color: {text_color} !important; }} /* Couleur des titres et textes dans la barre latérale */
+    
+    /* Styles pour les boutons */
+    .stButton > button {{
+        background-color: {button_bg}; /* Fond des boutons généraux */
+        color: {button_text}; /* Couleur du texte des boutons */
+    }}
+    
+    /* Styles pour les expandeurs */
+    .streamlit-expanderHeader {{
+        background-color: {input_bg_color}; /* Fond des en-têtes d'expandeur */
+        color: {text_color}; /* Couleur du texte des en-têtes d'expandeur */
+        transition: all 0.3s ease-out; /* Transition fluide pour l'expansion */
+    }}
+    .streamlit-expanderHeader[aria-expanded="true"] {{ transform: translateX(10px); }} /* Effet de déplacement quand l'expandeur est ouvert */
+    .streamlit-expanderContent {{
+        background-color: {"#1E90FF" if theme == "Sombre" else "#F0F0F0"} !important; /* Couleur de fond du contenu de l'expandeur */
+        padding: 10px;
+        border-radius: 5px; /* Coins arrondis du contenu de l'expandeur */
+    }}
+    
+    /* Styles pour le selectbox */
+    .stSelectbox > div > div:first-child,
+    .stSelectbox > div > div:nth-child(2),
+    .stSelectbox ul {{
+        background-color: {select_bg} !important; /* Fond des éléments du selectbox */
+        color: {"white" if theme == "Sombre" else "#333333"} !important; /* Couleur du texte des éléments du selectbox */
+    }}
+    .stSelectbox ul li:hover, .stSelectbox ul li[aria-selected="true"] {{
+        background-color: {"#ffe4e1" if theme == "Sombre" else "#e6f7ff"} !important; /* Fond des éléments au survol et sélectionnés */
+    }}
+
+     /* Styles pour le selectbox */
+    [data-testid="stSelectboxVirtualDropdown"], .st-emotion-cache-1o2fhjg.e1811lun0 {{
+        background-color: {select_option_bg} !important; /* Fond des éléments du selectbox */
+        color: {select_text_color} !important; /* Couleur du texte des options */
+    }}
+
+    [data-testid="stSelectboxVirtualDropdown"] li[aria-selected="true"], .st-emotion-cache-1o2fhjg.e1811lun0[aria-selected="true"] {{
+        background-color: {"#1A6BBF" if theme == "Sombre" else "#ffcccb"} !important; /* Fond des options sélectionnées */
+    }}
+    
+
+    [data-testid="stSelectboxVirtualDropdown"] li:hover {{
+        background-color: {"#1A6BBF" if theme == "Sombre" else "#ffa07a"} !important; /* Fond au survol des options */
+    }}
+    
+    /* Styles pour les boutons de feedback */
+    .stChatMessage .stButton > button {{
+        background-color: transparent !important; /* Fond transparent pour les boutons dans les messages */
+        border: none !important;
+        box-shadow: none !important;
+        padding: 0 !important;
+    }}
+    .stChatMessage .stButton > button:hover {{
+        background-color: rgba(0, 0, 0, 0.05) !important; /* Léger changement de fond au survol */
+    }}
+    
+    /* Styles pour les boutons de la barre latérale */
+    [data-testid="stSidebar"] .stButton > button {{
+        background-color: {"#1E90FF" if theme == "Sombre" else "#FFD700"} !important; /* Fond des boutons spécifiques dans la barre latérale */
+        color: {button_text} !important; /* Couleur du texte des boutons dans la barre latérale */
+        border: inherit !important;
+        box-shadow: inherit !important;
+        padding: inherit !important;
+    }}
+    
+    /* Assurez-vous que tous les textes sont lisibles */
+    body, p, h1, h2, h3, h4, h5, h6, span, div {{
+        color: {"#E0E0E0" if theme == "Sombre" else "#4a4a4a"} !important; /* Couleur des textes dans tout le contenu de la page, */
+    }}
+    
+    </style>
+    """, unsafe_allow_html=True)
+
+
+# ajout de logo sur l'en -tête de l'application (cette focntion est appelé dans inject_custom_css(theme))
+def get_base64_encoded_image(image_file):
+    with open(image_file, "rb") as img_file:
+        return base64.b64encode(img_file.read()).decode('utf-8')
+
+# ajout de logo sur l'en -tête de l'application et animation du logo
+def inject_custom_css(theme):
+    # Définition des paramètres visuels en fonction du thème
+    is_dark_theme = theme == "Sombre"
+    
+    # Sélection du logo et des couleurs selon le thème
+    logo_file = "assets/logo2.svg" if is_dark_theme else "assets/logo.svg"
+    background_color = "#333333" if is_dark_theme else "#eef3f7" 
+    text_color = "#E0E0E0" if is_dark_theme else "#333333"
+    # Encodage du logo en base64
+    logo_base64 = get_base64_encoded_image(logo_file)
+
+    st.markdown(
+    f"""
+    <style>
+    @keyframes rotate {{
+        from {{
+            transform: rotate(0deg);
+        }}
+        to {{
+            transform: rotate(360deg);
+        }}
+    }}
+    
+    .stApp header {{
+        display: flex;
+        align-items: center;
+        background-color: {background_color} !important;
+        padding-left: 240px !important;
+    }}
+    
+    .stApp header::before {{
+        content: "";
+        background-image: url("data:image/svg+xml;base64,{logo_base64}");
+        background-repeat: no-repeat;
+        background-position: center;
+        background-size: contain;
+        width: 190px;
+        height: 190px;
+        position: absolute;
+        left: 350px;
+        animation: rotate 10s linear infinite;
+    }}
+    
+    .stApp header::after {{
+        content: "Colibri IA: la précision d'un colibri, la puissance d'un assistant";
+        font-size: 15px;
+        font-weight: normal;
+        color: {text_color};
+        margin-left: 250px;
+        background-color: rgba(0, 0, 0, 0.02) !important;
+    }}
+    </style>
+    """,
+    unsafe_allow_html=True,)
+
+
+# ajout de logo sur la sidebar avec un texte simulant un en-tête
+def add_sidebar_logo(theme):
+    # Définition des couleurs en fonction du thème
+    text_color = "#E0E0E0" if theme == "Sombre" else "#333333"
+    # #E0E0E0 : Gris très clair, presque blanc (pour le thème sombre)
+    # #333333 : Gris très foncé, presque noir (pour le thème clair)
+
+    # Utilisation d'un contexte 'with' pour la barre latérale
+    with st.sidebar:
+        # Ajout du logo (identique pour les deux thèmes)
+        st.image("assets/logo.png", width=150)
+
+        # Ajout du titre avec la couleur appropriée
+        st.markdown(
+            f"""
+            <h2 style="color:{text_color};">Colibri Assistant</h2>
+            """,
+            unsafe_allow_html=True
+        )
+
+        # Ajout d'une ligne de séparation
+        st.write("---")
+ 
+
+def apply_chat_styles(theme):
+    light_user_bg = "#d1e7ff"  # bleu clair désaturé (arrière-plan des messages utilisateur en thème clair)
+    light_assistant_bg = "#f0f0f0"  # Gris perle (arrière-plan des messages assistant en thème clair)
+    dark_user_bg = "#0E4C92"  # #0E4C92 = bleu foncé (arrière-plan des messages utilisateur en thème sombre)
+    dark_assistant_bg = "#1A472A"  # #1A472A = vert foncé (arrière-plan des messages assistant en thème sombre)
+    
+    user_bg = dark_user_bg if theme == "Sombre" else light_user_bg  # Utilise la couleur bleu foncé en thème sombre ou bleu clair désaturé en thème clair pour l'utilisateur
+    assistant_bg = dark_assistant_bg if theme == "Sombre" else light_assistant_bg  # Utilise la couleur vert foncé en thème sombre ou Gris perle en thème clair pour l'assistant
+    text_color = "#E0E0E0" if theme == "Sombre" else "#000000"  # Utilise la couleur gris clair (#E0E0E0) en thème sombre ou noir (#000000) en thème clair pour le texte
+
+    st.markdown(f"""
+    <style>
+    [data-testid="stChatMessage"] {{
+        width: fit-content !important;
+        max-width: 80% !important;
+        padding: 10px !important;
+        border-radius: 15px !important;
+        margin-bottom: 10px !important;
+        clear: both !important;
+    }}
+
+    [data-testid="stChatMessage"]:has([data-testid="stChatMessageAvatarUser"]) {{
+        background-color: {user_bg} !important;  # Arrière-plan des messages utilisateur (dépend du thème)
+        border-radius: 15px 15px 0 15px !important;
+        margin-left: auto !important;
+        margin-right: 10px !important;
+        text-align: right !important;
+        float: right !important;
+    }}
+
+    [data-testid="stChatMessage"]:not(:has([data-testid="stChatMessageAvatarUser"])) {{
+        background-color: {assistant_bg} !important;  # Arrière-plan des messages assistant (dépend du thème)
+        border-radius: 15px 15px 15px 0 !important;
+        margin-right: auto !important;
+        margin-left: 10px !important;
+        text-align: left !important;
+        float: left !important;
+    }}
+
+    [data-testid="stChatMessage"] * {{
+        color: {text_color} !important;  # Couleur du texte (dépend du thème)
+    }}   
+    
+    </style>
+    """, unsafe_allow_html=True)
+
+def inject_custom_toggle_css(theme):
+    # Définition de la couleur du texte en fonction du thème
+    text_color = "#e0e0e0" if theme == "Sombre" else "#666666"
+    # #e0e0e0 : Gris très clair, presque blanc (pour le thème sombre)
+    # #666666 : Gris moyen foncé (pour le thème clair)
+
+    # CSS personnalisé pour le style des toggles
+    custom_css = f"""
+    <style>
+    /* Style pour le titre du toggle */
+    .stExpander .stToggleButton label,
+    .streamlit-expanderHeader .stToggleButton label {{
+        color: {text_color} !important;
+        font-weight: bold;
+    }}
+    </style>
+    """
+    # Injection du CSS personnalisé dans la page Streamlit
+    st.markdown(custom_css, unsafe_allow_html=True)
+
+
+def create_custom_footer():
+    footer = """
+    <style>
+    .footer {
+        position: fixed;
+        left: 0;
+        bottom: 0;
+        width: 100%;
+        background-color: #0E1117;  # Couleur de fond sombre, ajustez selon votre thème
+        color: #FAFAFA;  # Couleur du texte claire
+        text-align: center;
+        padding: 10px;
+        font-size: 14px;
+    }
+    </style>
+    <div class="footer">
+        <p>© 2024 Votre Entreprise. Tous droits réservés.</p>
+    </div>
+    """
+    st.markdown(footer, unsafe_allow_html=True)        
+
+# Fonction pour permettre à l'utilisateur de changer de thème avec un toggle
+def theme_switcher():
+    current_theme = st.session_state.get('user_theme', 'Clair')
+    
+    # Utiliser des colonnes Streamlit pour l'alignement
+    col1, col2 = st.columns([0.9, 4])  # Ajustez les ratios selon vos besoins
+    
+    with col1:
+        # Toggle sans label
+        is_dark = st.toggle("", value=current_theme == "Sombre", key=f"theme_toggle", label_visibility="collapsed")
+    
+    with col2:
+        # Label personnalisé
+        title_color = "#FF6B6B" if current_theme == "Sombre" else "#1E90FF"
+        st.markdown(f'<p style="color: {title_color}; font-weight: normal; margin-top: 5px;">Thème sombre</i>', unsafe_allow_html=True)
+    
+    new_theme = "Sombre" if is_dark else "Clair"
+    
+    if new_theme != current_theme:
+        st.session_state.user_theme = new_theme
+        save_theme_preference(new_theme)
+        apply_theme(new_theme)
+        apply_chat_styles(new_theme)
+        st.rerun()
+
+# Cette fonction supprimera certains styles par défaut de Streamlit qui pourraient interférer avec vos styles personnalisés.
+def remove_streamlit_style():
+    st.markdown("""
+        <style>
+        #MainMenu {visibility: hidden;}
+        footer {visibility: hidden;}
+        </style>
+    """, unsafe_allow_html=True)
+# Appelez cette fonction au début de votre improved_ui
+
+
+def force_streamlit_style_update():
+    st.markdown("""
+        <script>
+        // Force Streamlit to re-evaluate the styles
+        window.parent.postMessage({
+            type: "streamlit:setComponentValue",
+            value: true
+        }, "*")
+        </script>
+    """, unsafe_allow_html=True
+    )
+
+# Fonction pour cacher les pages de navigation spécifiques (voir dossier pages)
+def hide_pages():
+    hide_pages_style = """
+    <style>
+        /* Cache les liens de navigation spécifiques */
+        .st-emotion-cache-79elbk .st-emotion-cache-1ekxtbt li:nth-child(2),  /* admin page */
+        .st-emotion-cache-79elbk .st-emotion-cache-1ekxtbt li:nth-child(3) { /* reset password */
+            display: none !important;
+        }
+        
+        /* Cache le séparateur si nécessaire */
+        .st-emotion-cache-uzxc3z {
+            display: none !important;
+        }
+        
+        /* Pour s'assurer que tous les liens sont cachés même si les classes changent */
+        [data-testid="stSidebarNavItems"] li a[href*="/admin_page"],
+        [data-testid="stSidebarNavItems"] li a[href*="/reset_password"] {
+            display: none !important;
+        }
+        
+        /* Cache les conteneurs parents si nécessaire */
+        [data-testid="stSidebarNavItems"] li:has(a[href*="/admin_page"]),
+        [data-testid="stSidebarNavItems"] li:has(a[href*="/reset_password"]) {
+            display: none !important;
+        }
+    </style>
+    """
+    st.markdown(hide_pages_style, unsafe_allow_html=True)
+
+
+# styles pour le dashboard administrateur (tooltip et bouttons)
+def apply_tooltip_and_button_styles(theme):
+    # Définition des couleurs en fonction du thème
+    text_color = "#E0E0E0" if theme == "Sombre" else "#333333"
+    background_color = "#333333" if theme == "Sombre" else "#fff"
+    border_color = "#ccc" if theme == "Sombre" else "#333"
+    button_background_color = "#4682B4" if theme == "Sombre" else "#FFD700"
+    button_text_color = "white" if theme == "Sombre" else "#8FBC8F"
+
+    # Injection des styles CSS pour les tooltips et le bouton de soumission du formulaire
+    st.markdown(
+        f"""
+        <style>
+        /* Style pour le conteneur principal du tooltip */
+        .st-emotion-cache-oj1fi {{
+            background-color: {background_color} !important;
+            color: {text_color} !important;
+            border: 1px solid {border_color} !important;
+        }}
+
+        /* Style pour le contenu du tooltip */
+        .stTooltipIcon {{
+            background-color: {background_color} !important;
+            color: {text_color} !important;
+        }}
+
+        /* Style pour le texte du tooltip */
+        .st-emotion-cache-1whk732 {{
+            color: {text_color} !important;
+        }}
+
+        /* Style pour l'icône du tooltip */
+        .stTooltipIcon svg {{
+            stroke: {text_color} !important;
+        }}
+
+        /* Style pour la couche externe du popup */
+        div[data-baseweb="tooltip"] {{
+            background-color: {background_color} !important;
+            border: 1px solid {border_color} !important;
+            padding: 5px 10px !important;
+            border-radius: 4px !important;
+            font-size: 12px !important;
+            z-index: 999999 !important;
+        }}
+
+        /* Style pour la couche interne du popup et son contenu */
+        div[data-baseweb="tooltip"] > div,
+        div[data-baseweb="tooltip"] > div > div {{
+            background-color: {background_color} !important;
+            color: {text_color} !important;
+        }}
+
+        /* Force la couleur du texte sur toutes les couches possibles */
+        div[data-baseweb="tooltip"] *,
+        div[role="tooltip"] * {{
+            color: {text_color} !important;
+            background-color: {background_color} !important;
+        }}
+
+        /* Style pour le bouton de soumission du formulaire */
+        div[data-testid="stFormSubmitButton"] button {{
+            background-color: {button_background_color} !important;
+            color: {button_text_color} !important;
+            border: none !important;
+            padding: 0.5rem 1rem !important;
+            border-radius: 0.5rem !important;
+            font-weight: bold !important;
+            transition: all 0.3s ease !important;
+        }}
+
+        /* Style pour le bouton de soumission du formulaire lorsqu'il est survolé */
+        div[data-testid="stFormSubmitButton"] button:hover {{
+            border: 1px solid red !important;  # Ajoutez cette ligne pour définir la bordure rouge au survol
+            opacity: 0.8 !important;
+        }}
+        </style>
+        """,
+        unsafe_allow_html=True
+    )